<?xml version="1.0"?>
<doc>
    <assembly>
        <name>ICSharpCode.NRefactory.CSharp</name>
    </assembly>
    <members>
        <member name="T:ICSharpCode.NRefactory.CSharp.Analysis.ControlFlowNode">
            <summary>
            Represents a node in the control flow graph of a C# method.
            </summary>
        </member>
        <member name="F:ICSharpCode.NRefactory.CSharp.Analysis.ControlFlowNodeType.None">
            <summary>
            Unknown node type
            </summary>
        </member>
        <member name="F:ICSharpCode.NRefactory.CSharp.Analysis.ControlFlowNodeType.StartNode">
            <summary>
            Node in front of a statement
            </summary>
        </member>
        <member name="F:ICSharpCode.NRefactory.CSharp.Analysis.ControlFlowNodeType.BetweenStatements">
            <summary>
            Node between two statements
            </summary>
        </member>
        <member name="F:ICSharpCode.NRefactory.CSharp.Analysis.ControlFlowNodeType.EndNode">
            <summary>
            Node at the end of a statement list
            </summary>
        </member>
        <member name="F:ICSharpCode.NRefactory.CSharp.Analysis.ControlFlowNodeType.LoopCondition">
            <summary>
            Node representing the position before evaluating the condition of a loop.
            </summary>
        </member>
        <member name="P:ICSharpCode.NRefactory.CSharp.Analysis.ControlFlowEdge.IsLeavingTryFinally">
            <summary>
            Gets whether this control flow edge is leaving any try-finally statements.
            </summary>
        </member>
        <member name="P:ICSharpCode.NRefactory.CSharp.Analysis.ControlFlowEdge.TryFinallyStatements">
            <summary>
            Gets the try-finally statements that this control flow edge is leaving.
            </summary>
        </member>
        <member name="F:ICSharpCode.NRefactory.CSharp.Analysis.ControlFlowEdgeType.Normal">
            <summary>
            Regular control flow.
            </summary>
        </member>
        <member name="F:ICSharpCode.NRefactory.CSharp.Analysis.ControlFlowEdgeType.ConditionTrue">
            <summary>
            Conditional control flow (edge taken if condition is true)
            </summary>
        </member>
        <member name="F:ICSharpCode.NRefactory.CSharp.Analysis.ControlFlowEdgeType.ConditionFalse">
            <summary>
            Conditional control flow (edge taken if condition is false)
            </summary>
        </member>
        <member name="F:ICSharpCode.NRefactory.CSharp.Analysis.ControlFlowEdgeType.Jump">
            <summary>
            A jump statement (goto, goto case, break or continue)
            </summary>
        </member>
        <member name="T:ICSharpCode.NRefactory.CSharp.Analysis.ControlFlowGraphBuilder">
            <summary>
            Constructs the control flow graph for C# statements.
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.Analysis.ControlFlowGraphBuilder.EvaluateConstant(ICSharpCode.NRefactory.CSharp.Expression)">
            <summary>
            Evaluates an expression.
            </summary>
            <returns>The constant value of the expression; or null if the expression is not a constant.</returns>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.Analysis.ControlFlowGraphBuilder.EvaluateCondition(ICSharpCode.NRefactory.CSharp.Expression)">
            <summary>
            Evaluates an expression.
            </summary>
            <returns>The value of the constant boolean expression; or null if the value is not a constant boolean expression.</returns>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.Analysis.ControlFlowGraphBuilder.ExportGraph(System.Collections.Generic.IList{ICSharpCode.NRefactory.CSharp.Analysis.ControlFlowNode})">
            <summary>
            Debugging helper that exports a control flow graph.
            </summary>
        </member>
        <member name="P:ICSharpCode.NRefactory.CSharp.Analysis.ControlFlowGraphBuilder.EvaluateOnlyPrimitiveConstants">
            <summary>
            Gets/Sets whether to handle only primitive expressions as constants (no complex expressions like "a + b").
            </summary>
        </member>
        <member name="T:ICSharpCode.NRefactory.CSharp.DepthFirstAstVisitor`2">
            <summary>
            AST visitor with a default implementation that visits all node depth-first.
            </summary>
        </member>
        <member name="T:ICSharpCode.NRefactory.CSharp.IAstVisitor`2">
            <summary>
            AST visitor.
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.Analysis.ControlFlowGraphBuilder.NodeCreationVisitor.CreateConnectedEndNode(ICSharpCode.NRefactory.CSharp.Statement,ICSharpCode.NRefactory.CSharp.Analysis.ControlFlowNode)">
            <summary>
            Creates an end node for <c>stmt</c> and connects <c>from</c> with the new node.
            </summary>
        </member>
        <member name="T:ICSharpCode.NRefactory.CSharp.Analysis.DefiniteAssignmentStatus">
            <summary>
            Represents the definite assignment status of a variable at a specific location.
            </summary>
        </member>
        <member name="F:ICSharpCode.NRefactory.CSharp.Analysis.DefiniteAssignmentStatus.PotentiallyAssigned">
            <summary>
            The variable might be assigned or unassigned.
            </summary>
        </member>
        <member name="F:ICSharpCode.NRefactory.CSharp.Analysis.DefiniteAssignmentStatus.DefinitelyAssigned">
            <summary>
            The variable is definitely assigned.
            </summary>
        </member>
        <member name="F:ICSharpCode.NRefactory.CSharp.Analysis.DefiniteAssignmentStatus.AssignedAfterTrueExpression">
            <summary>
            The variable is definitely assigned iff the expression results in the value 'true'.
            </summary>
        </member>
        <member name="F:ICSharpCode.NRefactory.CSharp.Analysis.DefiniteAssignmentStatus.AssignedAfterFalseExpression">
            <summary>
            The variable is definitely assigned iff the expression results in the value 'false'.
            </summary>
        </member>
        <member name="F:ICSharpCode.NRefactory.CSharp.Analysis.DefiniteAssignmentStatus.CodeUnreachable">
            <summary>
            The code is unreachable.
            </summary>
        </member>
        <member name="T:ICSharpCode.NRefactory.CSharp.Analysis.DefiniteAssignmentAnalysis">
            <summary>
            Implements the C# definite assignment analysis (C# 4.0 Spec: §5.3 Definite assignment)
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.Analysis.DefiniteAssignmentAnalysis.SetAnalyzedRange(ICSharpCode.NRefactory.CSharp.Statement,ICSharpCode.NRefactory.CSharp.Statement,System.Boolean,System.Boolean)">
            <summary>
            Sets the range of statements to be analyzed.
            This method can be used to restrict the analysis to only a part of the method.
            Only the control flow paths that are fully contained within the selected part will be analyzed.
            </summary>
            <remarks>By default, both 'start' and 'end' are inclusive.</remarks>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.Analysis.DefiniteAssignmentAnalysis.ExportGraph">
            <summary>
            Exports the CFG. This method is intended to help debugging issues related to definite assignment.
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.Analysis.DefiniteAssignmentAnalysis.EvaluateConstant(ICSharpCode.NRefactory.CSharp.Expression)">
            <summary>
            Evaluates an expression.
            </summary>
            <returns>The constant value of the expression; or null if the expression is not a constant.</returns>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.Analysis.DefiniteAssignmentAnalysis.EvaluateCondition(ICSharpCode.NRefactory.CSharp.Expression)">
            <summary>
            Evaluates an expression.
            </summary>
            <returns>The value of the constant boolean expression; or null if the value is not a constant boolean expression.</returns>
        </member>
        <member name="P:ICSharpCode.NRefactory.CSharp.Analysis.DefiniteAssignmentAnalysis.UnassignedVariableUses">
            <summary>
            Gets the unassigned usages of the previously analyzed variable.
            </summary>
        </member>
        <member name="T:ICSharpCode.NRefactory.CSharp.Analysis.ReachabilityAnalysis">
            <summary>
            Statement reachability analysis.
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.AstNode.GetRegion">
            <summary>
            Gets the region from StartLocation to EndLocation for this node.
            The file name of the region is set based on the parent SyntaxTree's file name.
            If this node is not connected to a whole compilation, the file name will be null.
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.AstNode.GetChildByRole``1(ICSharpCode.NRefactory.Role{``0})">
            <summary>
            Gets the first child with the specified role.
            Returns the role's null object if the child is not found.
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.AstNode.AddChildUnsafe(ICSharpCode.NRefactory.CSharp.AstNode,ICSharpCode.NRefactory.Role)">
            <summary>
            Adds a child without performing any safety checks.
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.AstNode.Remove">
            <summary>
            Removes this node from its parent.
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.AstNode.ReplaceWith(ICSharpCode.NRefactory.CSharp.AstNode)">
            <summary>
            Replaces this node with the new node.
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.AstNode.Clone">
            <summary>
            Clones the whole subtree starting at this AST node.
            </summary>
            <remarks>Annotations are copied over to the new nodes; and any annotations implementing ICloneable will be cloned.</remarks>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.AstNode.GetNodeAt(System.Int32,System.Int32,System.Predicate{ICSharpCode.NRefactory.CSharp.AstNode})">
            <summary>
            Gets the node specified by T at the location line, column. This is useful for getting a specific node from the tree. For example searching
            the current method declaration.
            (End exclusive)
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.AstNode.GetNodeAt(ICSharpCode.NRefactory.TextLocation,System.Predicate{ICSharpCode.NRefactory.CSharp.AstNode})">
            <summary>
            Gets the node specified by pred at location. This is useful for getting a specific node from the tree. For example searching
            the current method declaration.
            (End exclusive)
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.AstNode.GetNodeAt``1(System.Int32,System.Int32)">
            <summary>
            Gets the node specified by T at the location line, column. This is useful for getting a specific node from the tree. For example searching
            the current method declaration.
            (End exclusive)
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.AstNode.GetNodeAt``1(ICSharpCode.NRefactory.TextLocation)">
            <summary>
            Gets the node specified by T at location. This is useful for getting a specific node from the tree. For example searching
            the current method declaration.
            (End exclusive)
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.AstNode.GetAdjacentNodeAt(System.Int32,System.Int32,System.Predicate{ICSharpCode.NRefactory.CSharp.AstNode})">
            <summary>
            Gets the node specified by pred at the location line, column. This is useful for getting a specific node from the tree. For example searching
            the current method declaration.
            (End inclusive)
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.AstNode.GetAdjacentNodeAt(ICSharpCode.NRefactory.TextLocation,System.Predicate{ICSharpCode.NRefactory.CSharp.AstNode})">
            <summary>
            Gets the node specified by pred at location. This is useful for getting a specific node from the tree. For example searching
            the current method declaration.
            (End inclusive)
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.AstNode.GetAdjacentNodeAt``1(System.Int32,System.Int32)">
            <summary>
            Gets the node specified by T at the location line, column. This is useful for getting a specific node from the tree. For example searching
            the current method declaration.
            (End inclusive)
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.AstNode.GetAdjacentNodeAt``1(ICSharpCode.NRefactory.TextLocation)">
            <summary>
            Gets the node specified by T at location. This is useful for getting a specific node from the tree. For example searching
            the current method declaration.
            (End inclusive)
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.AstNode.GetNodeContaining(ICSharpCode.NRefactory.TextLocation,ICSharpCode.NRefactory.TextLocation)">
            <summary>
            Gets the node that fully contains the range from startLocation to endLocation.
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.AstNode.GetText(ICSharpCode.NRefactory.CSharp.CSharpFormattingOptions)">
            <summary>
            Gets the node as formatted C# output.
            </summary>
            <param name='formattingOptions'>
            Formatting options.
            </param>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.AstNode.Contains(System.Int32,System.Int32)">
            <summary>
            Returns true, if the given coordinates (line, column) are in the node.
            </summary>
            <returns>
            True, if the given coordinates are between StartLocation and EndLocation (exclusive); otherwise, false.
            </returns>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.AstNode.Contains(ICSharpCode.NRefactory.TextLocation)">
            <summary>
            Returns true, if the given coordinates are in the node.
            </summary>
            <returns>
            True, if location is between StartLocation and EndLocation (exclusive); otherwise, false.
            </returns>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.AstNode.IsInside(System.Int32,System.Int32)">
            <summary>
            Returns true, if the given coordinates (line, column) are in the node.
            </summary>
            <returns>
            True, if the given coordinates are between StartLocation and EndLocation (inclusive); otherwise, false.
            </returns>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.AstNode.IsInside(ICSharpCode.NRefactory.TextLocation)">
            <summary>
            Returns true, if the given coordinates are in the node.
            </summary>
            <returns>
            True, if location is between StartLocation and EndLocation (inclusive); otherwise, false.
            </returns>
        </member>
        <member name="P:ICSharpCode.NRefactory.CSharp.AstNode.Ancestors">
            <summary>
            Gets the ancestors of this node (excluding this node itself)
            </summary>
        </member>
        <member name="P:ICSharpCode.NRefactory.CSharp.AstNode.AncestorsAndSelf">
            <summary>
            Gets the ancestors of this node (including this node itself)
            </summary>
        </member>
        <member name="P:ICSharpCode.NRefactory.CSharp.AstNode.Descendants">
            <summary>
            Gets all descendants of this node (excluding this node itself).
            </summary>
        </member>
        <member name="P:ICSharpCode.NRefactory.CSharp.AstNode.DescendantsAndSelf">
            <summary>
            Gets all descendants of this node (including this node itself).
            </summary>
        </member>
        <member name="T:ICSharpCode.NRefactory.CSharp.AstNodeCollection`1">
            <summary>
            Represents the children of an AstNode that have a specific role.
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.AstNodeCollection`1.FirstOrNullObject(System.Func{`0,System.Boolean})">
            <summary>
            Returns the first element for which the predicate returns true,
            or the null node (AstNode with IsNull=true) if no such object is found.
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.AstNodeCollection`1.LastOrNullObject(System.Func{`0,System.Boolean})">
            <summary>
            Returns the last element for which the predicate returns true,
            or the null node (AstNode with IsNull=true) if no such object is found.
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.AstNodeCollection`1.AcceptVisitor(ICSharpCode.NRefactory.CSharp.IAstVisitor)">
            <summary>
            Applies the <paramref name="visitor"/> to all nodes in this collection.
            </summary>
        </member>
        <member name="T:ICSharpCode.NRefactory.CSharp.AstType">
            <summary>
            A type reference in the C# AST.
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.AstType.ToTypeReference(ICSharpCode.NRefactory.TypeSystem.InterningProvider)">
            <summary>
            Create an ITypeReference for this AstType.
            Uses the context (ancestors of this node) to determine the correct <see cref="T:ICSharpCode.NRefactory.CSharp.NameLookupMode"/>.
            </summary>
            <remarks>
            The resulting type reference will read the context information from the
            <see cref="T:ICSharpCode.NRefactory.TypeSystem.ITypeResolveContext"/>:
            For resolving type parameters, the CurrentTypeDefinition/CurrentMember is used.
            For resolving simple names, the current namespace and usings from the CurrentUsingScope
            (on CSharpTypeResolveContext only) is used.
            </remarks>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.AstType.ToTypeReference(ICSharpCode.NRefactory.CSharp.NameLookupMode,ICSharpCode.NRefactory.TypeSystem.InterningProvider)">
            <summary>
            Create an ITypeReference for this AstType.
            </summary>
            <remarks>
            The resulting type reference will read the context information from the
            <see cref="T:ICSharpCode.NRefactory.TypeSystem.ITypeResolveContext"/>:
            For resolving type parameters, the CurrentTypeDefinition/CurrentMember is used.
            For resolving simple names, the current namespace and usings from the CurrentUsingScope
            (on CSharpTypeResolveContext only) is used.
            </remarks>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.AstType.GetNameLookupMode">
            <summary>
            Gets the name lookup mode from the context (looking at the ancestors of this <see cref="T:ICSharpCode.NRefactory.CSharp.AstType"/>).
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.AstType.MakePointerType">
            <summary>
            Creates a pointer type from this type by nesting it in a <see cref="T:ICSharpCode.NRefactory.CSharp.ComposedType"/>.
            If this type already is a pointer type, this method just increases the PointerRank of the existing pointer type.
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.AstType.MakeArrayType(System.Int32)">
            <summary>
            Creates an array type from this type by nesting it in a <see cref="T:ICSharpCode.NRefactory.CSharp.ComposedType"/>.
            If this type already is an array type, the additional rank is prepended to the existing array specifier list.
            Thus, <c>new SimpleType("T").MakeArrayType(1).MakeArrayType(2)</c> will result in "T[,][]".
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.AstType.MakeNullableType">
            <summary>
            Creates a nullable type from this type by nesting it in a <see cref="T:ICSharpCode.NRefactory.CSharp.ComposedType"/>.
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.AstType.Member(System.String)">
            <summary>
            Builds an expression that can be used to access a static member on this type.
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.AstType.MemberType(System.String,ICSharpCode.NRefactory.CSharp.AstType[])">
            <summary>
            Builds an expression that can be used to access a static member on this type.
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.AstType.MemberType(System.String,System.Collections.Generic.IEnumerable{ICSharpCode.NRefactory.CSharp.AstType})">
            <summary>
            Builds an expression that can be used to access a static member on this type.
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.AstType.Invoke(System.String,System.Collections.Generic.IEnumerable{ICSharpCode.NRefactory.CSharp.Expression})">
            <summary>
            Builds an invocation expression using this type as target.
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.AstType.Invoke(System.String,ICSharpCode.NRefactory.CSharp.Expression[])">
            <summary>
            Builds an invocation expression using this type as target.
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.AstType.Invoke(System.String,System.Collections.Generic.IEnumerable{ICSharpCode.NRefactory.CSharp.AstType},System.Collections.Generic.IEnumerable{ICSharpCode.NRefactory.CSharp.Expression})">
            <summary>
            Builds an invocation expression using this type as target.
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.AstType.Create(System.String)">
            <summary>
            Creates a simple AstType from a dotted name.
            Does not support generics, arrays, etc. - just simple dotted names,
            e.g. namespace names.
            </summary>
        </member>
        <member name="T:ICSharpCode.NRefactory.CSharp.DocumentationReference">
            <summary>
            Represents a 'cref' reference in XML documentation.
            </summary>
        </member>
        <member name="P:ICSharpCode.NRefactory.CSharp.DocumentationReference.EntityType">
            <summary>
            Gets/Sets the entity type.
            Possible values are:
              <c>EntityType.Operator</c> for operators,
              <c>EntityType.Indexer</c> for indexers,
              <c>EntityType.TypeDefinition</c> for references to primitive types,
              and <c>EntityType.None</c> for everything else.
            </summary>
        </member>
        <member name="P:ICSharpCode.NRefactory.CSharp.DocumentationReference.OperatorType">
            <summary>
            Gets/Sets the operator type.
            This property is only used when EntityType==Operator.
            </summary>
        </member>
        <member name="P:ICSharpCode.NRefactory.CSharp.DocumentationReference.HasParameterList">
            <summary>
            Gets/Sets whether a parameter list was provided.
            </summary>
        </member>
        <member name="P:ICSharpCode.NRefactory.CSharp.DocumentationReference.DeclaringType">
            <summary>
            Gets/Sets the declaring type.
            </summary>
        </member>
        <member name="P:ICSharpCode.NRefactory.CSharp.DocumentationReference.MemberName">
            <summary>
            Gets/sets the member name.
            This property is only used when EntityType==None.
            </summary>
        </member>
        <member name="P:ICSharpCode.NRefactory.CSharp.DocumentationReference.ConversionOperatorReturnType">
            <summary>
            Gets/Sets the return type of conversion operators.
            This property is only used when EntityType==Operator and OperatorType is explicit or implicit.
            </summary>
        </member>
        <member name="T:ICSharpCode.NRefactory.CSharp.IdentifierExpressionBackreference">
            <summary>
            Matches identifier expressions that have the same identifier as the referenced variable/type definition/method definition.
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.SyntaxTree.GetTypes(System.Boolean)">
            <summary>
            Gets all defined types in this syntax tree.
            </summary>
            <returns>
            A list containing <see cref="T:ICSharpCode.NRefactory.CSharp.TypeDeclaration"/> or <see cref="T:ICSharpCode.NRefactory.CSharp.DelegateDeclaration"/> nodes.
            </returns>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.SyntaxTree.ToTypeSystem">
            <summary>
            Converts this syntax tree into a parsed file that can be stored in the type system.
            </summary>
        </member>
        <member name="P:ICSharpCode.NRefactory.CSharp.SyntaxTree.FileName">
            <summary>
            Gets/Sets the file name of this syntax tree.
            </summary>
        </member>
        <member name="P:ICSharpCode.NRefactory.CSharp.SyntaxTree.ConditionalSymbols">
            <summary>
            Gets the conditional symbols used to parse the source file. Note that this list contains
            the conditional symbols at the start of the first token in the file - including the ones defined
            in the source file.
            </summary>
        </member>
        <member name="P:ICSharpCode.NRefactory.CSharp.SyntaxTree.TopExpression">
            <summary>
            Gets the expression that was on top of the parse stack.
            This is the only way to get an expression that isn't part of a statment.
            (eg. when an error follows an expression).
            
            This is used for code completion to 'get the expression before a token - like ., &lt;, ('.
            </summary>
        </member>
        <member name="T:ICSharpCode.NRefactory.CSharp.ArraySpecifier">
            <summary>
            [,,,]
            </summary>
        </member>
        <member name="T:ICSharpCode.NRefactory.CSharp.CSharpTokenNode">
            <summary>
            Represents a token in C#. Note that the type of the token is defined through the TokenRole.
            </summary>
            <remarks>
            In all non null c# token nodes the Role of a CSharpToken must be a TokenRole.
            </remarks>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.CSharpUtil.NegateRelationalOperator(ICSharpCode.NRefactory.CSharp.BinaryOperatorType)">
            <summary>
            Get negation of the specified relational operator
            </summary>
            <returns>
            negation of the specified relational operator, or BinaryOperatorType.Any if it's not a relational operator
            </returns>
        </member>
        <member name="T:ICSharpCode.NRefactory.CSharp.DepthFirstAstVisitor">
            <summary>
            AST visitor with a default implementation that visits all node depth-first.
            </summary>
        </member>
        <member name="T:ICSharpCode.NRefactory.CSharp.IAstVisitor">
            <summary>
            AST visitor.
            </summary>
        </member>
        <member name="T:ICSharpCode.NRefactory.CSharp.DepthFirstAstVisitor`1">
            <summary>
            AST visitor with a default implementation that visits all node depth-first.
            </summary>
        </member>
        <member name="T:ICSharpCode.NRefactory.CSharp.IAstVisitor`1">
            <summary>
            AST visitor.
            </summary>
        </member>
        <member name="T:ICSharpCode.NRefactory.CSharp.ErrorNode">
            <summary>
            Represents a parsing error in the ast. At the moment it only represents missing closing bracket.
            This closing bracket is replaced by a node at the highest possible position.
            (To make GetAstNodeAt (line, col) working).
            </summary>
        </member>
        <member name="T:ICSharpCode.NRefactory.CSharp.AnonymousMethodExpression">
            <summary>
            [async] delegate(Parameters) {Body}
            </summary>
        </member>
        <member name="T:ICSharpCode.NRefactory.CSharp.Expression">
            <summary>
            Base class for expressions.
            </summary>
            <remarks>
            This class is useful even though it doesn't provide any additional functionality:
            It can be used to communicate more information in APIs, e.g. "this subnode will always be an expression"
            </remarks>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.Expression.Member(System.String)">
            <summary>
            Builds an member reference expression using this expression as target.
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.Expression.Indexer(System.Collections.Generic.IEnumerable{ICSharpCode.NRefactory.CSharp.Expression})">
            <summary>
            Builds an indexer expression using this expression as target.
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.Expression.Indexer(ICSharpCode.NRefactory.CSharp.Expression[])">
            <summary>
            Builds an indexer expression using this expression as target.
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.Expression.Invoke(System.String,System.Collections.Generic.IEnumerable{ICSharpCode.NRefactory.CSharp.Expression})">
            <summary>
            Builds an invocation expression using this expression as target.
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.Expression.Invoke(System.String,ICSharpCode.NRefactory.CSharp.Expression[])">
            <summary>
            Builds an invocation expression using this expression as target.
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.Expression.Invoke(System.String,System.Collections.Generic.IEnumerable{ICSharpCode.NRefactory.CSharp.AstType},System.Collections.Generic.IEnumerable{ICSharpCode.NRefactory.CSharp.Expression})">
            <summary>
            Builds an invocation expression using this expression as target.
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.Expression.Invoke(System.Collections.Generic.IEnumerable{ICSharpCode.NRefactory.CSharp.Expression})">
            <summary>
            Builds an invocation expression using this expression as target.
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.Expression.Invoke(ICSharpCode.NRefactory.CSharp.Expression[])">
            <summary>
            Builds an invocation expression using this expression as target.
            </summary>
        </member>
        <member name="T:ICSharpCode.NRefactory.CSharp.AnonymousTypeCreateExpression">
            <summary>
            new { [ExpressionList] }
            </summary>
        </member>
        <member name="T:ICSharpCode.NRefactory.CSharp.ArrayCreateExpression">
            <summary>
            new Type[Dimensions]
            </summary>
        </member>
        <member name="P:ICSharpCode.NRefactory.CSharp.ArrayCreateExpression.AdditionalArraySpecifiers">
            <summary>
            Gets additional array ranks (those without size info).
            Empty for "new int[5,1]"; will contain a single element for "new int[5][]".
            </summary>
        </member>
        <member name="T:ICSharpCode.NRefactory.CSharp.ArrayInitializerExpression">
            <summary>
            { Elements }
            </summary>
        </member>
        <member name="P:ICSharpCode.NRefactory.CSharp.ArrayInitializerExpression.IsSingleElement">
            <summary>
            For ease of use purposes in the resolver the ast representation
            of { a, b, c }  is { {a}, {b}, {c} }.
            If IsSingleElement is true then this array initializer expression is a generated one.
            That has no meaning in the source code (and contains no brace tokens).
            </summary>
        </member>
        <member name="T:ICSharpCode.NRefactory.CSharp.ArrayInitializerExpression.SingleArrayInitializerExpression">
            <summary>
            Single elements in array initializers are represented with this special class.
            </summary>
        </member>
        <member name="T:ICSharpCode.NRefactory.CSharp.AsExpression">
            <summary>
            Expression as TypeReference
            </summary>
        </member>
        <member name="T:ICSharpCode.NRefactory.CSharp.AssignmentExpression">
            <summary>
            Left Operator= Right
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.AssignmentExpression.GetCorrespondingBinaryOperator(ICSharpCode.NRefactory.CSharp.AssignmentOperatorType)">
            <summary>
            Gets the binary operator for the specified compound assignment operator.
            Returns null if 'op' is not a compound assignment.
            </summary>
        </member>
        <member name="F:ICSharpCode.NRefactory.CSharp.AssignmentOperatorType.Assign">
            <summary>left = right</summary>
        </member>
        <member name="F:ICSharpCode.NRefactory.CSharp.AssignmentOperatorType.Add">
            <summary>left += right</summary>
        </member>
        <member name="F:ICSharpCode.NRefactory.CSharp.AssignmentOperatorType.Subtract">
            <summary>left -= right</summary>
        </member>
        <member name="F:ICSharpCode.NRefactory.CSharp.AssignmentOperatorType.Multiply">
            <summary>left *= right</summary>
        </member>
        <member name="F:ICSharpCode.NRefactory.CSharp.AssignmentOperatorType.Divide">
            <summary>left /= right</summary>
        </member>
        <member name="F:ICSharpCode.NRefactory.CSharp.AssignmentOperatorType.Modulus">
            <summary>left %= right</summary>
        </member>
        <!-- Badly formed XML comment ignored for member "F:ICSharpCode.NRefactory.CSharp.AssignmentOperatorType.ShiftLeft" -->
        <member name="F:ICSharpCode.NRefactory.CSharp.AssignmentOperatorType.ShiftRight">
            <summary>left >>= right</summary>
        </member>
        <!-- Badly formed XML comment ignored for member "F:ICSharpCode.NRefactory.CSharp.AssignmentOperatorType.BitwiseAnd" -->
        <member name="F:ICSharpCode.NRefactory.CSharp.AssignmentOperatorType.BitwiseOr">
            <summary>left |= right</summary>
        </member>
        <member name="F:ICSharpCode.NRefactory.CSharp.AssignmentOperatorType.ExclusiveOr">
            <summary>left ^= right</summary>
        </member>
        <member name="F:ICSharpCode.NRefactory.CSharp.AssignmentOperatorType.Any">
            <summary>Any operator (for pattern matching)</summary>
        </member>
        <member name="T:ICSharpCode.NRefactory.CSharp.BaseReferenceExpression">
            <summary>
            base
            </summary>
        </member>
        <member name="T:ICSharpCode.NRefactory.CSharp.BinaryOperatorExpression">
            <summary>
            Left Operator Right
            </summary>
        </member>
        <member name="F:ICSharpCode.NRefactory.CSharp.BinaryOperatorType.Any">
            <summary>
            Any binary operator (used in pattern matching)
            </summary>
        </member>
        <member name="F:ICSharpCode.NRefactory.CSharp.BinaryOperatorType.BitwiseAnd">
            <summary>left &amp; right</summary>
        </member>
        <member name="F:ICSharpCode.NRefactory.CSharp.BinaryOperatorType.BitwiseOr">
            <summary>left | right</summary>
        </member>
        <member name="F:ICSharpCode.NRefactory.CSharp.BinaryOperatorType.ConditionalAnd">
            <summary>left &amp;&amp; right</summary>
        </member>
        <member name="F:ICSharpCode.NRefactory.CSharp.BinaryOperatorType.ConditionalOr">
            <summary>left || right</summary>
        </member>
        <member name="F:ICSharpCode.NRefactory.CSharp.BinaryOperatorType.ExclusiveOr">
            <summary>left ^ right</summary>
        </member>
        <member name="F:ICSharpCode.NRefactory.CSharp.BinaryOperatorType.GreaterThan">
            <summary>left &gt; right</summary>
        </member>
        <member name="F:ICSharpCode.NRefactory.CSharp.BinaryOperatorType.GreaterThanOrEqual">
            <summary>left &gt;= right</summary>
        </member>
        <member name="F:ICSharpCode.NRefactory.CSharp.BinaryOperatorType.Equality">
            <summary>left == right</summary>
        </member>
        <member name="F:ICSharpCode.NRefactory.CSharp.BinaryOperatorType.InEquality">
            <summary>left != right</summary>
        </member>
        <member name="F:ICSharpCode.NRefactory.CSharp.BinaryOperatorType.LessThan">
            <summary>left &lt; right</summary>
        </member>
        <member name="F:ICSharpCode.NRefactory.CSharp.BinaryOperatorType.LessThanOrEqual">
            <summary>left &lt;= right</summary>
        </member>
        <member name="F:ICSharpCode.NRefactory.CSharp.BinaryOperatorType.Add">
            <summary>left + right</summary>
        </member>
        <member name="F:ICSharpCode.NRefactory.CSharp.BinaryOperatorType.Subtract">
            <summary>left - right</summary>
        </member>
        <member name="F:ICSharpCode.NRefactory.CSharp.BinaryOperatorType.Multiply">
            <summary>left * right</summary>
        </member>
        <member name="F:ICSharpCode.NRefactory.CSharp.BinaryOperatorType.Divide">
            <summary>left / right</summary>
        </member>
        <member name="F:ICSharpCode.NRefactory.CSharp.BinaryOperatorType.Modulus">
            <summary>left % right</summary>
        </member>
        <member name="F:ICSharpCode.NRefactory.CSharp.BinaryOperatorType.ShiftLeft">
            <summary>left &lt;&lt; right</summary>
        </member>
        <member name="F:ICSharpCode.NRefactory.CSharp.BinaryOperatorType.ShiftRight">
            <summary>left &gt;&gt; right</summary>
        </member>
        <member name="F:ICSharpCode.NRefactory.CSharp.BinaryOperatorType.NullCoalescing">
            <summary>left ?? right</summary>
        </member>
        <member name="T:ICSharpCode.NRefactory.CSharp.CastExpression">
            <summary>
            (CastTo)Expression
            </summary>
        </member>
        <member name="T:ICSharpCode.NRefactory.CSharp.CheckedExpression">
            <summary>
            checked(Expression)
            </summary>
        </member>
        <member name="T:ICSharpCode.NRefactory.CSharp.ConditionalExpression">
            <summary>
            Condition ? TrueExpression : FalseExpression
            </summary>
        </member>
        <member name="T:ICSharpCode.NRefactory.CSharp.DefaultValueExpression">
            <summary>
            default(Type)
            </summary>
        </member>
        <member name="T:ICSharpCode.NRefactory.CSharp.DirectionExpression">
            <summary>
            ref Expression
            </summary>
        </member>
        <member name="T:ICSharpCode.NRefactory.CSharp.EmptyExpression">
            <summary>
            Type&lt;[EMPTY]&gt;
            </summary>
        </member>
        <member name="T:ICSharpCode.NRefactory.CSharp.IndexerExpression">
            <summary>
            Target[Arguments]
            </summary>
        </member>
        <member name="T:ICSharpCode.NRefactory.CSharp.InvocationExpression">
            <summary>
            Target(Arguments)
            </summary>
        </member>
        <member name="T:ICSharpCode.NRefactory.CSharp.IsExpression">
            <summary>
            Expression is Type
            </summary>
        </member>
        <member name="T:ICSharpCode.NRefactory.CSharp.LambdaExpression">
            <summary>
            [async] Parameters => Body
            </summary>
        </member>
        <member name="T:ICSharpCode.NRefactory.CSharp.MemberReferenceExpression">
            <summary>
            Target.MemberName
            </summary>
        </member>
        <member name="T:ICSharpCode.NRefactory.CSharp.NamedArgumentExpression">
            <summary>
            Represents a named argument passed to a method or attribute.
            name: expression
            </summary>
        </member>
        <member name="T:ICSharpCode.NRefactory.CSharp.NamedExpression">
            <summary>
            name = expression
            This isn't the same as 'assign' even though it has the same syntax.
            This expression is used in object initializers and for named attribute arguments [Attr(FieldName = value)].
            </summary>
        </member>
        <member name="T:ICSharpCode.NRefactory.CSharp.NullReferenceExpression">
            <summary>
            null
            </summary>
        </member>
        <member name="T:ICSharpCode.NRefactory.CSharp.ObjectCreateExpression">
            <summary>
            new Type(Arguments) { Initializer }
            </summary>
        </member>
        <member name="T:ICSharpCode.NRefactory.CSharp.ParenthesizedExpression">
            <summary>
            ( Expression )
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.ParenthesizedExpression.ActsAsParenthesizedExpression(ICSharpCode.NRefactory.CSharp.AstNode)">
            <summary>
            Gets whether the expression acts like a parenthesized expression,
            i.e. whether information about the expected type (for lambda type inference) flows
            into the inner expression.
            </summary>
            <returns>Returns true for ParenthesizedExpression, CheckedExpression or UncheckedExpression; false otherwise.</returns>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.ParenthesizedExpression.UnpackParenthesizedExpression(ICSharpCode.NRefactory.CSharp.Expression)">
            <summary>
            Unpacks the given expression if it is a ParenthesizedExpression, CheckedExpression or UncheckedExpression.
            </summary>
        </member>
        <member name="T:ICSharpCode.NRefactory.CSharp.PointerReferenceExpression">
            <summary>
            Target->MemberName
            </summary>
        </member>
        <member name="T:ICSharpCode.NRefactory.CSharp.PrimitiveExpression">
            <summary>
            Represents a literal value.
            </summary>
        </member>
        <member name="T:ICSharpCode.NRefactory.CSharp.QueryContinuationClause">
            <summary>
            Represents a query continuation.
            "(from .. select ..) into Identifier" or "(from .. group .. by ..) into Identifier"
            Note that "join .. into .." is not a query continuation!
            
            This is always the first(!!) clause in a query expression.
            The tree for "from a in b select c into d select e" looks like this:
            new QueryExpression {
            	new QueryContinuationClause {
            		PrecedingQuery = new QueryExpression {
            			new QueryFromClause(a in b),
            			new QuerySelectClause(c)
            		},
            		Identifier = d
            	},
            	new QuerySelectClause(e)
            }
            </summary>
        </member>
        <member name="T:ICSharpCode.NRefactory.CSharp.QueryJoinClause">
            <summary>
            Represents a join or group join clause.
            </summary>
        </member>
        <member name="T:ICSharpCode.NRefactory.CSharp.SizeOfExpression">
            <summary>
            sizeof(Type)
            </summary>
        </member>
        <member name="T:ICSharpCode.NRefactory.CSharp.StackAllocExpression">
            <summary>
            stackalloc Type[Count]
            </summary>
        </member>
        <member name="T:ICSharpCode.NRefactory.CSharp.ThisReferenceExpression">
            <summary>
            this
            </summary>
        </member>
        <member name="T:ICSharpCode.NRefactory.CSharp.TypeOfExpression">
            <summary>
            typeof(Type)
            </summary>
        </member>
        <member name="T:ICSharpCode.NRefactory.CSharp.TypeReferenceExpression">
            <summary>
            Represents an AstType as an expression.
            This is used when calling a method on a primitive type: "int.Parse()"
            </summary>
        </member>
        <member name="T:ICSharpCode.NRefactory.CSharp.UnaryOperatorExpression">
            <summary>
            Operator Expression
            </summary>
        </member>
        <member name="F:ICSharpCode.NRefactory.CSharp.UnaryOperatorType.Any">
            <summary>
            Any unary operator (used in pattern matching)
            </summary>
        </member>
        <member name="F:ICSharpCode.NRefactory.CSharp.UnaryOperatorType.Not">
            <summary>Logical not (!a)</summary>
        </member>
        <member name="F:ICSharpCode.NRefactory.CSharp.UnaryOperatorType.BitNot">
            <summary>Bitwise not (~a)</summary>
        </member>
        <member name="F:ICSharpCode.NRefactory.CSharp.UnaryOperatorType.Minus">
            <summary>Unary minus (-a)</summary>
        </member>
        <member name="F:ICSharpCode.NRefactory.CSharp.UnaryOperatorType.Plus">
            <summary>Unary plus (+a)</summary>
        </member>
        <member name="F:ICSharpCode.NRefactory.CSharp.UnaryOperatorType.Increment">
            <summary>Pre increment (++a)</summary>
        </member>
        <member name="F:ICSharpCode.NRefactory.CSharp.UnaryOperatorType.Decrement">
            <summary>Pre decrement (--a)</summary>
        </member>
        <member name="F:ICSharpCode.NRefactory.CSharp.UnaryOperatorType.PostIncrement">
            <summary>Post increment (a++)</summary>
        </member>
        <member name="F:ICSharpCode.NRefactory.CSharp.UnaryOperatorType.PostDecrement">
            <summary>Post decrement (a--)</summary>
        </member>
        <member name="F:ICSharpCode.NRefactory.CSharp.UnaryOperatorType.Dereference">
            <summary>Dereferencing (*a)</summary>
        </member>
        <!-- Badly formed XML comment ignored for member "F:ICSharpCode.NRefactory.CSharp.UnaryOperatorType.AddressOf" -->
        <member name="F:ICSharpCode.NRefactory.CSharp.UnaryOperatorType.Await">
            <summary>C# 5.0 await</summary>
        </member>
        <member name="T:ICSharpCode.NRefactory.CSharp.UncheckedExpression">
            <summary>
            unchecked(Expression)
            </summary>
        </member>
        <member name="T:ICSharpCode.NRefactory.CSharp.UndocumentedExpression">
            <summary>
            Represents undocumented expressions.
            </summary>
        </member>
        <member name="T:ICSharpCode.NRefactory.CSharp.Attribute">
            <summary>
            Attribute(Arguments)
            </summary>
        </member>
        <member name="T:ICSharpCode.NRefactory.CSharp.AttributeSection">
            <summary>
            [AttributeTarget: Attributes]
            </summary>
        </member>
        <member name="F:ICSharpCode.NRefactory.CSharp.CommentType.SingleLine">
            <summary>
            "//" comment
            </summary>
        </member>
        <member name="F:ICSharpCode.NRefactory.CSharp.CommentType.MultiLine">
            <summary>
            "/* */" comment
            </summary>
        </member>
        <member name="F:ICSharpCode.NRefactory.CSharp.CommentType.Documentation">
            <summary>
            "///" comment
            </summary>
        </member>
        <member name="F:ICSharpCode.NRefactory.CSharp.CommentType.InactiveCode">
            <summary>
            Inactive code (code in non-taken "#if")
            </summary>
        </member>
        <member name="F:ICSharpCode.NRefactory.CSharp.CommentType.MultiLineDocumentation">
            <summary>
            "/** */" comment
            </summary>
        </member>
        <member name="P:ICSharpCode.NRefactory.CSharp.Comment.IsDocumentation">
            <summary>
            Returns true if the <see cref="P:ICSharpCode.NRefactory.CSharp.Comment.CommentType"/> is Documentation or MultiLineDocumentation.
            </summary>
        </member>
        <member name="T:ICSharpCode.NRefactory.CSharp.Constraint">
            <summary>
            where TypeParameter : BaseTypes
            </summary>
            <remarks>
            new(), struct and class constraints are represented using a PrimitiveType "new", "struct" or "class"
            </remarks>
        </member>
        <member name="T:ICSharpCode.NRefactory.CSharp.DelegateDeclaration">
            <summary>
            delegate ReturnType Name&lt;TypeParameters&gt;(Parameters) where Constraints;
            </summary>
        </member>
        <!-- Badly formed XML comment ignored for member "T:ICSharpCode.NRefactory.CSharp.ExternAliasDeclaration" -->
        <member name="T:ICSharpCode.NRefactory.CSharp.NamespaceDeclaration">
            <summary>
            namespace Name { Members }
            </summary>
        </member>
        <member name="P:ICSharpCode.NRefactory.CSharp.NamespaceDeclaration.FullName">
            <summary>
            Gets the full namespace name (including any parent namespaces)
            </summary>
        </member>
        <member name="T:ICSharpCode.NRefactory.CSharp.TypeDeclaration">
            <summary>
            class Name&lt;TypeParameters&gt; : BaseTypes where Constraints;
            </summary>
        </member>
        <member name="T:ICSharpCode.NRefactory.CSharp.TypeParameterDeclaration">
            <summary>
            [in|out] Name
            
            Represents a type parameter.
            Note: mirroring the C# syntax, constraints are not part of the type parameter declaration, but belong
            to the parent type or method.
            </summary>
        </member>
        <member name="T:ICSharpCode.NRefactory.CSharp.UsingAliasDeclaration">
            <summary>
            using Alias = Import;
            </summary>
        </member>
        <member name="T:ICSharpCode.NRefactory.CSharp.UsingDeclaration">
            <summary>
            using Import;
            </summary>
        </member>
        <member name="F:ICSharpCode.NRefactory.CSharp.Modifiers.Any">
            <summary>
            Special value used to match any modifiers during pattern matching.
            </summary>
        </member>
        <member name="F:ICSharpCode.NRefactory.CSharp.NodeType.TypeReference">
            <summary>
            AstType
            </summary>
        </member>
        <member name="F:ICSharpCode.NRefactory.CSharp.NodeType.TypeDeclaration">
            <summary>
            Type or delegate declaration
            </summary>
        </member>
        <member name="F:ICSharpCode.NRefactory.CSharp.NodeType.Whitespace">
            <summary>
            Comment or whitespace or pre-processor directive 
            </summary>
        </member>
        <member name="F:ICSharpCode.NRefactory.CSharp.NodeType.Pattern">
            <summary>
            Placeholder for a pattern
            </summary>
        </member>
        <member name="T:ICSharpCode.NRefactory.CSharp.BlockStatement">
            <summary>
            { Statements }
            </summary>
        </member>
        <member name="T:ICSharpCode.NRefactory.CSharp.Statement">
            <summary>
            Base class for statements.
            </summary>
            <remarks>
            This class is useful even though it doesn't provide any additional functionality:
            It can be used to communicate more information in APIs, e.g. "this subnode will always be a statement"
            </remarks>
        </member>
        <member name="T:ICSharpCode.NRefactory.CSharp.BreakStatement">
            <summary>
            break;
            </summary>
        </member>
        <member name="T:ICSharpCode.NRefactory.CSharp.CheckedStatement">
            <summary>
            checked BodyBlock
            </summary>
        </member>
        <member name="T:ICSharpCode.NRefactory.CSharp.ContinueStatement">
            <summary>
            continue;
            </summary>
        </member>
        <member name="T:ICSharpCode.NRefactory.CSharp.DoWhileStatement">
            <summary>
            "do EmbeddedStatement while(Condition);"
            </summary>
        </member>
        <member name="T:ICSharpCode.NRefactory.CSharp.EmptyStatement">
            <summary>
            ;
            </summary>
        </member>
        <member name="T:ICSharpCode.NRefactory.CSharp.ExpressionStatement">
            <summary>
            Expression;
            </summary>
        </member>
        <member name="T:ICSharpCode.NRefactory.CSharp.FixedStatement">
            <summary>
            fixed (Type Variables) EmbeddedStatement
            </summary>
        </member>
        <member name="T:ICSharpCode.NRefactory.CSharp.ForeachStatement">
            <summary>
            foreach (Type VariableName in InExpression) EmbeddedStatement
            </summary>
        </member>
        <member name="T:ICSharpCode.NRefactory.CSharp.ForStatement">
            <summary>
            for (Initializers; Condition; Iterators) EmbeddedStatement
            </summary>
        </member>
        <member name="P:ICSharpCode.NRefactory.CSharp.ForStatement.Initializers">
            <summary>
            Gets the list of initializer statements.
            Note: this contains multiple statements for "for (a = 2, b = 1; a > b; a--)", but contains
            only a single statement for "for (int a = 2, b = 1; a > b; a--)" (a single VariableDeclarationStatement with two variables)
            </summary>
        </member>
        <member name="T:ICSharpCode.NRefactory.CSharp.GotoStatement">
            <summary>
            "goto Label;"
            </summary>
        </member>
        <member name="T:ICSharpCode.NRefactory.CSharp.GotoCaseStatement">
            <summary>
            or "goto case LabelExpression;"
            </summary>
        </member>
        <member name="P:ICSharpCode.NRefactory.CSharp.GotoCaseStatement.LabelExpression">
            <summary>
            Used for "goto case LabelExpression;"
            </summary>
        </member>
        <member name="T:ICSharpCode.NRefactory.CSharp.GotoDefaultStatement">
            <summary>
            or "goto default;"
            </summary>
        </member>
        <member name="T:ICSharpCode.NRefactory.CSharp.IfElseStatement">
            <summary>
            if (Condition) TrueStatement else FalseStatement
            </summary>
        </member>
        <member name="T:ICSharpCode.NRefactory.CSharp.LabelStatement">
            <summary>
            Label:
            </summary>
        </member>
        <member name="T:ICSharpCode.NRefactory.CSharp.LockStatement">
            <summary>
            lock (Expression) EmbeddedStatement;
            </summary>
        </member>
        <member name="T:ICSharpCode.NRefactory.CSharp.ReturnStatement">
            <summary>
            return Expression;
            </summary>
        </member>
        <member name="T:ICSharpCode.NRefactory.CSharp.SwitchStatement">
            <summary>
            switch (Expression) { SwitchSections }
            </summary>
        </member>
        <member name="P:ICSharpCode.NRefactory.CSharp.CaseLabel.Expression">
            <summary>
            Gets or sets the expression. The expression can be null - if the expression is null, it's the default switch section.
            </summary>
        </member>
        <member name="T:ICSharpCode.NRefactory.CSharp.ThrowStatement">
            <summary>
            throw Expression;
            </summary>
        </member>
        <member name="T:ICSharpCode.NRefactory.CSharp.TryCatchStatement">
            <summary>
            try TryBlock CatchClauses finally FinallyBlock
            </summary>
        </member>
        <member name="T:ICSharpCode.NRefactory.CSharp.CatchClause">
            <summary>
            catch (Type VariableName) { Body }
            </summary>
        </member>
        <member name="T:ICSharpCode.NRefactory.CSharp.UncheckedStatement">
            <summary>
            unchecked BodyBlock
            </summary>
        </member>
        <member name="T:ICSharpCode.NRefactory.CSharp.UnsafeStatement">
            <summary>
            unsafe { Body }
            </summary>
        </member>
        <member name="T:ICSharpCode.NRefactory.CSharp.UsingStatement">
            <summary>
            using (ResourceAcquisition) EmbeddedStatement
            </summary>
        </member>
        <member name="P:ICSharpCode.NRefactory.CSharp.UsingStatement.ResourceAcquisition">
            <summary>
            Either a VariableDeclarationStatement, or an Expression.
            </summary>
        </member>
        <member name="T:ICSharpCode.NRefactory.CSharp.WhileStatement">
            <summary>
            "while (Condition) EmbeddedStatement"
            </summary>
        </member>
        <member name="T:ICSharpCode.NRefactory.CSharp.YieldBreakStatement">
            <summary>
            yield break;
            </summary>
        </member>
        <member name="T:ICSharpCode.NRefactory.CSharp.YieldReturnStatement">
            <summary>
            yield return Expression;
            </summary>
        </member>
        <member name="T:ICSharpCode.NRefactory.CSharp.Accessor">
            <summary>
            get/set/add/remove
            </summary>
        </member>
        <member name="P:ICSharpCode.NRefactory.CSharp.CustomEventDeclaration.PrivateImplementationType">
            <summary>
            Gets/Sets the type reference of the interface that is explicitly implemented.
            Null node if this member is not an explicit interface implementation.
            </summary>
        </member>
        <member name="T:ICSharpCode.NRefactory.CSharp.FixedVariableInitializer">
            <summary>
            Name [ CountExpression ]
            </summary>
        </member>
        <member name="P:ICSharpCode.NRefactory.CSharp.IndexerDeclaration.PrivateImplementationType">
            <summary>
            Gets/Sets the type reference of the interface that is explicitly implemented.
            Null node if this member is not an explicit interface implementation.
            </summary>
        </member>
        <member name="P:ICSharpCode.NRefactory.CSharp.MethodDeclaration.PrivateImplementationType">
            <summary>
            Gets/Sets the type reference of the interface that is explicitly implemented.
            Null node if this member is not an explicit interface implementation.
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.OperatorDeclaration.GetOperatorType(System.String)">
            <summary>
            Gets the operator type from the method name, or null, if the method does not represent one of the known operator types.
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.OperatorDeclaration.GetName(ICSharpCode.NRefactory.CSharp.OperatorType)">
            <summary>
            Gets the method name for the operator type. ("op_Addition", "op_Implicit", etc.)
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.OperatorDeclaration.GetToken(ICSharpCode.NRefactory.CSharp.OperatorType)">
            <summary>
            Gets the token for the operator type ("+", "implicit", etc.)
            </summary>
        </member>
        <member name="P:ICSharpCode.NRefactory.CSharp.PropertyDeclaration.PrivateImplementationType">
            <summary>
            Gets/Sets the type reference of the interface that is explicitly implemented.
            Null node if this member is not an explicit interface implementation.
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.CSharpProjectContent.SetAssemblyName(System.String)">
            <summary>
            Sets both the short and the full assembly names.
            </summary>
            <param name="newAssemblyName">New full assembly name.</param>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.CSharpProjectContent.AddOrUpdateFiles(System.Collections.Generic.IEnumerable{ICSharpCode.NRefactory.TypeSystem.IUnresolvedFile})">
            <summary>
            Adds the specified files to the project content.
            If a file with the same name already exists, updated the existing file.
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.CSharpProjectContent.AddOrUpdateFiles(ICSharpCode.NRefactory.TypeSystem.IUnresolvedFile[])">
            <summary>
            Adds the specified files to the project content.
            If a file with the same name already exists, this method updates the existing file.
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.CSharpProjectContent.RemoveFiles(System.Collections.Generic.IEnumerable{System.String})">
            <summary>
            Removes the files with the specified names.
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.CSharpProjectContent.RemoveFiles(System.String[])">
            <summary>
            Removes the files with the specified names.
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.AstFormattingVisitor.ApplyChanges">
            <summary>
            Applies the changes to the input document.
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.AstFormattingVisitor.ApplyChanges(ICSharpCode.NRefactory.CSharp.Refactoring.Script)">
            <summary>
            Applies the changes to the given Script instance.
            </summary>
        </member>
        <member name="T:ICSharpCode.NRefactory.CSharp.CodeDomConvertVisitor">
            <summary>
            Converts from C# AST to CodeDom.
            </summary>
            <remarks>
            The conversion is intended for use in the SharpDevelop forms designer.
            </remarks>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.CodeDomConvertVisitor.Convert(ICSharpCode.NRefactory.TypeSystem.ICompilation,ICSharpCode.NRefactory.CSharp.SyntaxTree,ICSharpCode.NRefactory.CSharp.TypeSystem.CSharpUnresolvedFile)">
            <summary>
            Converts a syntax tree to CodeDom.
            </summary>
            <param name="syntaxTree">The input syntax tree.</param>
            <param name="compilation">The current compilation.</param>
            <param name="unresolvedFile">CSharpUnresolvedFile, used for resolving.</param>
            <returns>Converted CodeCompileUnit</returns>
            <remarks>
            This conversion process requires a resolver because it needs to distinguish field/property/event references etc.
            </remarks>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.CodeDomConvertVisitor.Convert(ICSharpCode.NRefactory.CSharp.AstNode,ICSharpCode.NRefactory.CSharp.Resolver.CSharpAstResolver)">
            <summary>
            Converts a C# AST node to CodeDom.
            </summary>
            <param name="node">The input node.</param>
            <param name="resolver">The AST resolver.</param>
            <returns>The node converted into CodeDom</returns>
            <remarks>
            This conversion process requires a resolver because it needs to distinguish field/property/event references etc.
            </remarks>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.CodeDomConvertVisitor.MakeSnippetExpression(ICSharpCode.NRefactory.CSharp.Expression)">
            <summary>
            Converts an expression by storing it as C# snippet.
            This is used for expressions that cannot be represented in CodeDom.
            </summary>
        </member>
        <member name="P:ICSharpCode.NRefactory.CSharp.CodeDomConvertVisitor.UseFullyQualifiedTypeNames">
            <summary>
            Gets/Sets whether the visitor should convert short type names into
            fully qualified type names.
            The default is <c>false</c>.
            </summary>
        </member>
        <member name="P:ICSharpCode.NRefactory.CSharp.CodeDomConvertVisitor.AllowSnippetNodes">
            <summary>
            Gets whether the visitor is allowed to produce snippet nodes for
            code that cannot be converted.
            The default is <c>true</c>. If this property is set to <c>false</c>,
            unconvertible code will throw a NotSupportedException.
            </summary>
        </member>
        <member name="T:ICSharpCode.NRefactory.CSharp.CSharpAmbience">
            <summary>
            C# ambience.
            </summary>
        </member>
        <member name="T:ICSharpCode.NRefactory.CSharp.InsertParenthesesVisitor">
            <summary>
            Inserts the parentheses into the AST that are needed to ensure the AST can be printed correctly.
            For example, if the AST contains
            BinaryOperatorExpresson(2, Mul, BinaryOperatorExpression(1, Add, 1))); printing that AST
            would incorrectly result in "2 * 1 + 1". By running InsertParenthesesVisitor, the necessary
            parentheses are inserted: "2 * (1 + 1)".
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.InsertParenthesesVisitor.GetPrecedence(ICSharpCode.NRefactory.CSharp.Expression)">
            <summary>
            Gets the row number in the C# 4.0 spec operator precedence table.
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.InsertParenthesesVisitor.ParenthesizeIfRequired(ICSharpCode.NRefactory.CSharp.Expression,System.Int32)">
            <summary>
            Parenthesizes the expression if it does not have the minimum required precedence.
            </summary>
        </member>
        <member name="P:ICSharpCode.NRefactory.CSharp.InsertParenthesesVisitor.InsertParenthesesForReadability">
            <summary>
            Gets/Sets whether the visitor should insert parentheses to make the code better looking.
            If this property is false, it will insert parentheses only where strictly required by the language spec.
            </summary>
        </member>
        <member name="T:ICSharpCode.NRefactory.CSharp.IOutputFormatter">
            <summary>
            Output formatter for the Output visitor.
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.IOutputFormatter.WriteIdentifier(System.String)">
            <summary>
            Writes an identifier.
            If the identifier conflicts with a keyword, the output visitor will
            call <c>WriteToken("@")</c> before calling WriteIdentifier().
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.IOutputFormatter.WriteKeyword(System.String)">
            <summary>
            Writes a keyword to the output.
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.IOutputFormatter.WriteToken(System.String)">
            <summary>
            Writes a token to the output.
            </summary>
        </member>
        <member name="T:ICSharpCode.NRefactory.CSharp.CSharpOutputVisitor">
            <summary>
            Outputs the AST.
            </summary>
        </member>
        <member name="F:ICSharpCode.NRefactory.CSharp.CSharpOutputVisitor.lastWritten">
            <summary>
            Used to insert the minimal amount of spaces so that the lexer recognizes the tokens that were written.
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.CSharpOutputVisitor.WriteSpecials(ICSharpCode.NRefactory.CSharp.AstNode,ICSharpCode.NRefactory.CSharp.AstNode)">
            <summary>
            Writes all specials from start to end (exclusive). Does not touch the positionStack.
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.CSharpOutputVisitor.WriteSpecialsUpToRole(ICSharpCode.NRefactory.Role)">
            <summary>
            Writes all specials between the current position (in the positionStack) and the next
            node with the specified role. Advances the current position.
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.CSharpOutputVisitor.WriteSpecialsUpToNode(ICSharpCode.NRefactory.CSharp.AstNode)">
            <summary>
            Writes all specials between the current position (in the positionStack) and the specified node.
            Advances the current position.
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.CSharpOutputVisitor.Comma(ICSharpCode.NRefactory.CSharp.AstNode,System.Boolean)">
            <summary>
            Writes a comma.
            </summary>
            <param name="nextNode">The next node after the comma.</param>
            <param name="noSpaceAfterComma">When set prevents printing a space after comma.</param>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.CSharpOutputVisitor.OptionalComma">
            <summary>
            Writes an optional comma, e.g. at the end of an enum declaration or in an array initializer
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.CSharpOutputVisitor.OptionalSemicolon">
            <summary>
            Writes an optional semicolon, e.g. at the end of a type or namespace declaration.
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.CSharpOutputVisitor.WriteKeyword(ICSharpCode.NRefactory.CSharp.TokenRole)">
            <summary>
            Writes a keyword, and all specials up to
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.CSharpOutputVisitor.Semicolon">
            <summary>
            Marks the end of a statement
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.CSharpOutputVisitor.Space(System.Boolean)">
            <summary>
            Writes a space depending on policy.
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.CSharpOutputVisitor.IsKeyword(System.String,ICSharpCode.NRefactory.CSharp.AstNode)">
            <summary>
            Determines whether the specified identifier is a keyword in the given context.
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.CSharpOutputVisitor.ConvertChar(System.Char)">
            <summary>
            Gets the escape sequence for the specified character.
            </summary>
            <remarks>This method does not convert ' or ".</remarks>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.CSharpOutputVisitor.ConvertString(System.String)">
            <summary>
            Converts special characters to escape sequences within the given string.
            </summary>
        </member>
        <member name="T:ICSharpCode.NRefactory.CSharp.TextWriterOutputFormatter">
            <summary>
            Writes C# code into a TextWriter.
            </summary>
        </member>
        <member name="T:ICSharpCode.NRefactory.CSharp.CompilerSettings">
            <summary>
            C# compiler settings.
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.CompilerSettings.#ctor">
            <summary>
            Creates a new CompilerSettings instance.
            </summary>
        </member>
        <member name="P:ICSharpCode.NRefactory.CSharp.CompilerSettings.AllowUnsafeBlocks">
            <summary>
            Gets/Sets whether <c>unsafe</c> code is allowed.
            The default is <c>true</c>. If set to false, parsing unsafe code will result in parser errors.
            </summary>
        </member>
        <member name="P:ICSharpCode.NRefactory.CSharp.CompilerSettings.CheckForOverflow">
            <summary>
            Gets/Sets whether overflow checking is enabled.
            The default is <c>false</c>. This setting effects semantic analysis.
            </summary>
        </member>
        <member name="P:ICSharpCode.NRefactory.CSharp.CompilerSettings.LanguageVersion">
            <summary>
            Gets/Sets the language version used by the parser.
            Using language constructs newer than the supplied version will result in parser errors.
            </summary>
        </member>
        <member name="P:ICSharpCode.NRefactory.CSharp.CompilerSettings.ConditionalSymbols">
            <summary>
            Gets/Sets the list of conditional symbols that are defined project-wide.
            </summary>
        </member>
        <member name="P:ICSharpCode.NRefactory.CSharp.CompilerSettings.SpecificWarningsAsErrors">
            <summary>
            Allows treating specific warnings as errors without setting <see cref="P:ICSharpCode.NRefactory.CSharp.CompilerSettings.TreatWarningsAsErrors"/> to true.
            </summary>
        </member>
        <member name="P:ICSharpCode.NRefactory.CSharp.CompilerSettings.DisabledWarnings">
            <summary>
            Disables the specified warnings.
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.CSharpParser.Parse(System.String,System.String)">
            <summary>
            Parses a C# code file.
            </summary>
            <param name="program">The source code to parse.</param>
            <param name="fileName">The file name. Used to identify the file (e.g. when building a type system).
            This can be an arbitrary identifier, NRefactory never tries to access the file on disk.</param>
            <returns>Returns the syntax tree.</returns>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.CSharpParser.Parse(System.IO.TextReader,System.String)">
            <summary>
            Parses a C# code file.
            </summary>
            <param name="reader">The text reader containing the source code to parse.</param>
            <param name="fileName">The file name. Used to identify the file (e.g. when building a type system).
            This can be an arbitrary identifier, NRefactory never tries to access the file on disk.</param>
            <returns>Returns the syntax tree.</returns>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.CSharpParser.Parse(Mono.CSharp.CompilerCompilationUnit,System.String)">
            <summary>
            Converts a Mono.CSharp syntax tree into an NRefactory syntax tree.
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.CSharpParser.Parse(System.IO.Stream,System.String)">
            <summary>
            Parses a C# code file.
            </summary>
            <param name="stream">The stream containing the source code to parse.</param>
            <param name="fileName">The file name. Used to identify the file (e.g. when building a type system).
            This can be an arbitrary identifier, NRefactory never tries to access the file on disk.</param>
            <returns>Returns the syntax tree.</returns>
        </member>
        <!-- Badly formed XML comment ignored for member "M:ICSharpCode.NRefactory.CSharp.CSharpParser.Parse(ICSharpCode.NRefactory.Editor.ITextSource,System.String)" -->
        <member name="P:ICSharpCode.NRefactory.CSharp.CSharpParser.CompilationUnitCallback">
            <summary>
            Callback that gets called with the Mono.CSharp syntax tree whenever some code is parsed.
            </summary>
        </member>
        <member name="P:ICSharpCode.NRefactory.CSharp.CSharpParser.GenerateTypeSystemMode">
            <summary>
            Specifies whether to run the parser in a special mode for generating the type system.
            If this property is true, the syntax tree will only contain nodes relevant for the
            <see cref="M:ICSharpCode.NRefactory.CSharp.SyntaxTree.ToTypeSystem"/> call and might be missing other nodes (e.g. method bodies).
            The default is false.
            </summary>
        </member>
        <member name="P:ICSharpCode.NRefactory.CSharp.CSharpParser.InitialLocation">
            <summary>
            Specifies the text location where parsing starts.
            This property can be used when parsing a part of a file to make the locations of the AstNodes
            refer to the position in the whole file.
            The default is (1,1).
            </summary>
        </member>
        <member name="T:Mono.CSharp.MemberCore">
            <summary>
              Base representation for members.  This is used to keep track
              of Name, Location and Modifier flags, and handling Attributes.
            </summary>
        </member>
        <member name="T:Mono.CSharp.Attributable">
            <summary>
              Base class for objects that can have Attributes applied to them.
            </summary>
        </member>
        <member name="M:Mono.CSharp.Attributable.ApplyAttributeBuilder(Mono.CSharp.Attribute,Mono.CSharp.MethodSpec,System.Byte[],Mono.CSharp.PredefinedAttributes)">
            <summary>
            Use member-specific procedure to apply attribute @a in @cb to the entity being built in @builder
            </summary>
        </member>
        <member name="P:Mono.CSharp.Attributable.AttributeTargets">
            <summary>
            Returns one AttributeTarget for this element.
            </summary>
        </member>
        <member name="P:Mono.CSharp.Attributable.ValidAttributeTargets">
            <summary>
            Gets list of valid attribute targets for explicit target declaration.
            The first array item is default target. Don't break this rule.
            </summary>
        </member>
        <member name="F:Mono.CSharp.MemberCore.mod_flags">
            <summary>
              Modifier flags that the user specified in the source code
            </summary>
        </member>
        <member name="F:Mono.CSharp.MemberCore.comment">
            <summary>
              XML documentation comment
            </summary>
        </member>
        <member name="F:Mono.CSharp.MemberCore.caching_flags">
            <summary>
              MemberCore flags at first detected then cached
            </summary>
        </member>
        <member name="M:Mono.CSharp.MemberCore.Emit">
            <summary>
            Base Emit method. This is also entry point for CLS-Compliant verification.
            </summary>
        </member>
        <member name="M:Mono.CSharp.MemberCore.GetAttributeObsolete">
            <summary>
            Returns instance of ObsoleteAttribute for this MemberCore
            </summary>
        </member>
        <member name="M:Mono.CSharp.MemberCore.CheckObsoleteness(Mono.CSharp.Location)">
            <summary>
            Checks for ObsoleteAttribute presence. It's used for testing of all non-types elements
            </summary>
        </member>
        <member name="M:Mono.CSharp.MemberCore.IsClsComplianceRequired">
            <summary>
            Analyze whether CLS-Compliant verification must be execute for this MemberCore.
            </summary>
        </member>
        <member name="M:Mono.CSharp.MemberCore.IsExposedFromAssembly">
            <summary>
            Returns true when MemberCore is exposed from assembly.
            </summary>
        </member>
        <member name="M:Mono.CSharp.MemberCore.EnableOverloadChecks(Mono.CSharp.MemberCore)">
            <summary>
            Returns true when a member supports multiple overloads (methods, indexers, etc)
            </summary>
        </member>
        <member name="M:Mono.CSharp.MemberCore.VerifyClsCompliance">
            <summary>
            The main virtual method for CLS-Compliant verifications.
            The method returns true if member is CLS-Compliant and false if member is not
            CLS-Compliant which means that CLS-Compliant tests are not necessary. A descendants override it
            and add their extra verifications.
            </summary>
        </member>
        <member name="P:Mono.CSharp.MemberCore.Location">
            <summary>
              Location where this declaration happens
            </summary>
        </member>
        <member name="P:Mono.CSharp.MemberCore.DocCommentHeader">
            <summary>
              Represents header string for documentation comment 
              for each member types.
            </summary>
        </member>
        <member name="P:Mono.CSharp.MemberCore.CLSAttributeValue">
            <summary>
            Goes through class hierarchy and gets value of first found CLSCompliantAttribute.
            If no is attribute exists then assembly CLSCompliantAttribute is returned.
            </summary>
        </member>
        <member name="P:Mono.CSharp.MemberCore.HasClsCompliantAttribute">
            <summary>
            Returns true if MemberCore is explicitly marked with CLSCompliantAttribute
            </summary>
        </member>
        <!-- Badly formed XML comment ignored for member "F:Mono.CSharp.TypeDefinition.pending" -->
        <member name="M:Mono.CSharp.TypeDefinition.AddIndexer(Mono.CSharp.Indexer)">
            <summary>
            Indexer has special handling in constrast to other AddXXX because the name can be driven by IndexerNameAttribute
            </summary>
        </member>
        <member name="M:Mono.CSharp.TypeDefinition.ResolveBaseTypes(Mono.CSharp.FullNamedExpression@)">
            <summary>
              This function computes the Base class and also the
              list of interfaces that the class or struct @c implements.
              
              The return value is an array (might be null) of
              interfaces implemented (as Types).
              
              The @base_class argument is set to the base object or null
              if this is `System.Object'. 
            </summary>
        </member>
        <member name="M:Mono.CSharp.TypeDefinition.Define">
            <summary>
              Populates our TypeBuilder with fields and methods
            </summary>
        </member>
        <member name="M:Mono.CSharp.TypeDefinition.VerifyImplements(Mono.CSharp.InterfaceMemberBase)">
            <summary>
              Performs checks for an explicit interface implementation.  First it
              checks whether the `interface_type' is a base inteface implementation.
              Then it checks whether `name' exists in the interface type.
            </summary>
        </member>
        <member name="P:Mono.CSharp.TypeDefinition.HasEquals">
            <summary>
            Method container contains Equals method
            </summary>
        </member>
        <member name="P:Mono.CSharp.TypeDefinition.HasGetHashCode">
            <summary>
            Method container contains GetHashCode method
            </summary>
        </member>
        <member name="M:Mono.CSharp.ClassOrStruct.DefineDefaultConstructor(System.Boolean)">
            <summary>
            Defines the default constructors 
            </summary>
        </member>
        <!-- Badly formed XML comment ignored for member "M:Mono.CSharp.Statement.Resolve(Mono.CSharp.BlockContext)" -->
        <member name="M:Mono.CSharp.Statement.ResolveUnreachable(Mono.CSharp.BlockContext,System.Boolean)">
            <summary>
              We already know that the statement is unreachable, but we still
              need to resolve it to catch errors.
            </summary>
        </member>
        <member name="M:Mono.CSharp.Statement.DoEmit(Mono.CSharp.EmitContext)">
            <summary>
              Return value indicates whether all code paths emitted return.
            </summary>
        </member>
        <member name="T:Mono.CSharp.Expression">
            <remarks>
              Base class for expressions
            </remarks>
        </member>
        <member name="M:Mono.CSharp.Expression.DoResolve(Mono.CSharp.ResolveContext)">
             <summary>
               Performs semantic analysis on the Expression
             </summary>
            
             <remarks>
               The Resolve method is invoked to perform the semantic analysis
               on the node.
            
               The return value is an expression (it can be the
               same expression in some cases) or a new
               expression that better represents this node.
               
               For example, optimizations of Unary (LiteralInt)
               would return a new LiteralInt with a negated
               value.
               
               If there is an error during semantic analysis,
               then an error should be reported (using Report)
               and a null value should be returned.
               
               There are two side effects expected from calling
               Resolve(): the the field variable "eclass" should
               be set to any value of the enumeration
               `ExprClass' and the type variable should be set
               to a valid type (this is the type of the
               expression).
             </remarks>
        </member>
        <member name="M:Mono.CSharp.Expression.Resolve(Mono.CSharp.ResolveContext,Mono.CSharp.ResolveFlags)">
             <summary>
               Resolves an expression and performs semantic analysis on it.
             </summary>
            
             <remarks>
               Currently Resolve wraps DoResolve to perform sanity
               checking and assertion checking on what we expect from Resolve.
             </remarks>
        </member>
        <member name="M:Mono.CSharp.Expression.Resolve(Mono.CSharp.ResolveContext)">
            <summary>
              Resolves an expression and performs semantic analysis on it.
            </summary>
        </member>
        <member name="M:Mono.CSharp.Expression.ResolveLValue(Mono.CSharp.ResolveContext,Mono.CSharp.Expression)">
             <summary>
               Resolves an expression for LValue assignment
             </summary>
            
             <remarks>
               Currently ResolveLValue wraps DoResolveLValue to perform sanity
               checking and assertion checking on what we expect from Resolve
             </remarks>
        </member>
        <member name="M:Mono.CSharp.Expression.Emit(Mono.CSharp.EmitContext)">
             <summary>
               Emits the code for the expression
             </summary>
            
             <remarks>
               The Emit method is invoked to generate the code
               for the expression.  
             </remarks>
        </member>
        <member name="M:Mono.CSharp.Expression.#ctor">
            <summary>
              Protected constructor.  Only derivate types should
              be able to be created
            </summary>
        </member>
        <member name="M:Mono.CSharp.Expression.ExprClassFromMemberInfo(Mono.CSharp.MemberSpec,Mono.CSharp.Location)">
            <summary>
              Returns a fully formed expression after a MemberLookup
            </summary>
            
        </member>
        <member name="M:Mono.CSharp.Expression.GetOperatorTrue(Mono.CSharp.ResolveContext,Mono.CSharp.Expression,Mono.CSharp.Location)">
            <summary>
              Returns an expression that can be used to invoke operator true
              on the expression if it exists.
            </summary>
        </member>
        <member name="M:Mono.CSharp.Expression.GetOperatorFalse(Mono.CSharp.ResolveContext,Mono.CSharp.Expression,Mono.CSharp.Location)">
            <summary>
              Returns an expression that can be used to invoke operator false
              on the expression if it exists.
            </summary>
        </member>
        <member name="M:Mono.CSharp.Expression.Error_UnexpectedKind(Mono.CSharp.IMemberContext,Mono.CSharp.Expression,System.String,System.String,Mono.CSharp.Location)">
            <summary>
              Reports that we were expecting `expr' to be of class `expected'
            </summary>
        </member>
        <member name="T:Mono.CSharp.Assign">
            <summary>
              The Assign node takes care of assigning the value of source into
              the expression represented by target.
            </summary>
        </member>
        <member name="T:Mono.CSharp.ExpressionStatement">
            <summary>
              This is just a base class for expressions that can
              appear on statements (invocations, object creation,
              assignments, post/pre increment and decrement).  The idea
              being that they would support an extra Emition interface that
              does not leave a result on the stack.
            </summary>
        </member>
        <member name="M:Mono.CSharp.ExpressionStatement.EmitStatement(Mono.CSharp.EmitContext)">
            <summary>
              Requests the expression to be emitted in a `statement'
              context.  This means that no new value is left on the
              stack after invoking this method (constrasted with
              Emit that will always leave a value on the stack).
            </summary>
        </member>
        <member name="M:Mono.CSharp.InterfaceMemberBase.FindBaseMember(Mono.CSharp.MemberSpec@,System.Boolean@)">
            <summary>
            Gets base method and its return type
            </summary>
        </member>
        <member name="T:Mono.CSharp.IMethodData">
            <summary>
            Interface for MethodData class. Holds links to parent members to avoid member duplication.
            </summary>
        </member>
        <member name="M:Mono.CSharp.MethodOrOperator.ConditionalConditions">
            <summary>
            Returns true if method has conditional attribute and the conditions is not defined (method is excluded).
            </summary>
        </member>
        <member name="T:Mono.CSharp.IAssignMethod">
             <summary>
               This interface is implemented by expressions that can be assigned to.
             </summary>
             <remarks>
               This interface is implemented by Expressions whose values can not
               store the result on the top of the stack.
            
               Expressions implementing this (Properties, Indexers and Arrays) would
               perform an assignment of the Expression "source" into its final
               location.
            
               No values on the top of the stack are expected to be left by
               invoking this method.
             </remarks>
        </member>
        <member name="T:Mono.CSharp.LocalTemporary">
             <summary>
               An Expression to hold a temporary value.
             </summary>
             <remarks>
               The LocalTemporary class is used to hold temporary values of a given
               type to "simulate" the expression semantics. The local variable is
               never captured.
            
               The local temporary is used to alter the normal flow of code generation
               basically it creates a local variable, and its emit instruction generates
               code to access this value, return its address or save its value.
            
               If `is_address' is true, then the value that we store is the address to the
               real value, and not the value itself.
            
               This is needed for a value type, because otherwise you just end up making a
               copy of the value on the stack and modifying it. You really need a pointer
               to the origional value so that you can modify it in that location. This
               Does not happen with a class because a class is a pointer -- so you always
               get the indirection.
            
             </remarks>
        </member>
        <member name="T:Mono.CSharp.IMemoryLocation">
            <summary>
              This interface is implemented by variables
            </summary>
        </member>
        <member name="M:Mono.CSharp.IMemoryLocation.AddressOf(Mono.CSharp.EmitContext,Mono.CSharp.AddressOp)">
             <summary>
               The AddressOf method should generate code that loads
               the address of the object and leaves it on the stack.
            
               The `mode' argument is used to notify the expression
               of whether this will be used to read from the address or
               write to the address.
            
               This is just a hint that can be used to provide good error
               reporting, and should have no other side effects. 
             </summary>
        </member>
        <member name="F:Mono.CSharp.ResolveContext.Switch">
            <summary>
              If this is non-null, points to the current switch statement
            </summary>
        </member>
        <member name="F:Mono.CSharp.ResolveContext.Options.CheckedScope">
             <summary>
               This flag tracks the `checked' state of the compilation,
               it controls whether we should generate code that does overflow
               checking, or if we generate code that ignores overflows.
            
               The default setting comes from the command line option to generate
               checked or unchecked code plus any source code changes using the
               checked/unchecked statements or expressions.   Contrast this with
               the ConstantCheckState flag.
             </summary>
        </member>
        <member name="F:Mono.CSharp.ResolveContext.Options.ConstantCheckState">
            <summary>
              The constant check state is always set to `true' and cant be changed
              from the command line.  The source code can change this setting with
              the `checked' and `unchecked' statements and expressions. 
            </summary>
        </member>
        <member name="F:Mono.CSharp.ResolveContext.Options.DoFlowAnalysis">
            <summary>
              Whether control flow analysis is enabled
            </summary>
        </member>
        <member name="F:Mono.CSharp.ResolveContext.Options.OmitStructFlowAnalysis">
            <summary>
              Whether control flow analysis is disabled on structs
              (only meaningful when DoFlowAnalysis is set)
            </summary>
        </member>
        <member name="F:Mono.CSharp.ResolveContext.Options.ProbingMode">
            
             Indicates the current context is in probing mode, no errors are reported. 
            
        </member>
        <member name="T:Mono.CSharp.MemberAccess">
            <summary>
              Implements the member access expression
            </summary>
        </member>
        <member name="T:Mono.CSharp.FullNamedExpression">
            <summary>
              Represents a namespace or a type.  The name of the class was inspired by
              section 10.8.1 (Fully Qualified Names).
            </summary>
        </member>
        <member name="T:Mono.CSharp.Invocation">
            <summary>
              Invocation of methods or delegates.
            </summary>
        </member>
        <member name="T:Mono.CSharp.MemberExpr">
            <summary>
              This class denotes an expression which evaluates to a member
              of a struct or a class.
            </summary>
        </member>
        <member name="M:Mono.CSharp.OverloadResolver.BetterFunction(Mono.CSharp.ResolveContext,Mono.CSharp.Arguments,Mono.CSharp.MemberSpec,Mono.CSharp.AParametersCollection,System.Boolean,Mono.CSharp.MemberSpec,Mono.CSharp.AParametersCollection,System.Boolean)">
            <summary>
              Determines "Better function" between candidate
              and the current best match
            </summary>
            <remarks>
               Returns a boolean indicating :
                false if candidate ain't better
                true  if candidate is better than the current best match
            </remarks>
        </member>
        <member name="P:Mono.CSharp.MemberExpr.Name">
            <summary>
              The name of this member.
            </summary>
        </member>
        <member name="P:Mono.CSharp.MemberExpr.IsInstance">
            <summary>
              Whether this is an instance member.
            </summary>
        </member>
        <member name="P:Mono.CSharp.MemberExpr.IsStatic">
            <summary>
              Whether this is a static member.
            </summary>
        </member>
        <member name="M:Mono.CSharp.Attribute.Error_AttributeEmitError(System.String)">
            <summary>
            This is rather hack. We report many emit attribute error with same error to be compatible with
            csc. But because csc has to report them this way because error came from ilasm we needn't.
            </summary>
        </member>
        <member name="M:Mono.CSharp.Attribute.ResolveAttributeType(System.Boolean)">
            <summary>
              Tries to resolve the type of the attribute. Flags an error if it can't, and complain is true.
            </summary>
        </member>
        <member name="M:Mono.CSharp.Attribute.GetValidTargets">
            <summary>
              Get a string containing a list of valid targets for the attribute 'attr'
            </summary>
        </member>
        <member name="M:Mono.CSharp.Attribute.GetIndexerAttributeValue">
            <summary>
            Returns custom name of indexer
            </summary>
        </member>
        <member name="M:Mono.CSharp.Attribute.GetConditionalAttributeValue">
            <summary>
            Returns condition of ConditionalAttribute
            </summary>
        </member>
        <member name="M:Mono.CSharp.Attribute.GetObsoleteAttribute">
            <summary>
            Creates the instance of ObsoleteAttribute from this attribute instance
            </summary>
        </member>
        <member name="M:Mono.CSharp.Attribute.GetClsCompliantAttributeValue">
            <summary>
            Returns value of CLSCompliantAttribute contructor parameter but because the method can be called
            before ApplyAttribute. We need to resolve the arguments.
            This situation occurs when class deps is differs from Emit order.  
            </summary>
        </member>
        <member name="M:Mono.CSharp.Attribute.IsSecurityActionValid">
            <summary>
            Tests permitted SecurityAction for assembly or other types
            </summary>
        </member>
        <member name="M:Mono.CSharp.Attribute.ExtractSecurityPermissionSet(Mono.CSharp.MethodSpec,System.Collections.Generic.Dictionary{System.Security.Permissions.SecurityAction,System.Security.PermissionSet}@)">
            <summary>
            Creates instance of SecurityAttribute class and add result of CreatePermission method to permission table.
            </summary>
            <returns></returns>
        </member>
        <member name="M:Mono.CSharp.Attribute.Emit(System.Collections.Generic.Dictionary{Mono.CSharp.Attribute,System.Collections.Generic.List{Mono.CSharp.Attribute}})">
            <summary>
            Emit attribute for Attributable symbol
            </summary>
        </member>
        <member name="M:Mono.CSharp.Attributes.CheckTargets">
            <summary>
            Checks whether attribute target is valid for the current element
            </summary>
        </member>
        <member name="M:Mono.CSharp.Attributes.SearchMulti(Mono.CSharp.PredefinedAttribute)">
            <summary>
            Returns all attributes of type 't'. Use it when attribute is AllowMultiple = true
            </summary>
        </member>
        <member name="T:Mono.CSharp.AttributeTester">
            <summary>
            Helper class for attribute verification routine.
            </summary>
        </member>
        <member name="M:Mono.CSharp.AttributeTester.Report_ObsoleteMessage(System.ObsoleteAttribute,System.String,Mono.CSharp.Location,Mono.CSharp.Report)">
            <summary>
            Common method for Obsolete error/warning reporting.
            </summary>
        </member>
        <member name="M:Mono.CSharp.ConstantFold.BinaryFold(Mono.CSharp.ResolveContext,Mono.CSharp.Binary.Operator,Mono.CSharp.Constant,Mono.CSharp.Constant,Mono.CSharp.Location)">
             <summary>
               Constant expression folder for binary operations.
            
               Returns null if the expression can not be folded.
             </summary>
        </member>
        <member name="M:Mono.CSharp.Class.ConditionalConditions">
            Search for at least one defined condition in ConditionalAttribute of attribute class
            Valid only for attribute classes.
        </member>
        <member name="T:Mono.CSharp.Interface">
            <summary>
              Interfaces
            </summary>
        </member>
        <member name="F:Mono.CSharp.Interface.AllowedModifiers">
            <summary>
              Modifiers allowed in a class declaration
            </summary>
        </member>
        <member name="T:Mono.CSharp.EmitContext">
            <summary>
              An Emit Context is created for each body of code (from methods,
              properties bodies, indexer bodies or constructor bodies)
            </summary>
        </member>
        <member name="F:Mono.CSharp.BuilderContext.Options.CheckedScope">
             <summary>
               This flag tracks the `checked' state of the compilation,
               it controls whether we should generate code that does overflow
               checking, or if we generate code that ignores overflows.
            
               The default setting comes from the command line option to generate
               checked or unchecked code plus any source code changes using the
               checked/unchecked statements or expressions.   Contrast this with
               the ConstantCheckState flag.
             </summary>
        </member>
        <member name="F:Mono.CSharp.EmitContext.return_type">
            <summary>
              The value that is allowed to be returned or NULL if there is no
              return type.
            </summary>
        </member>
        <member name="F:Mono.CSharp.EmitContext.temporary_storage">
            <summary>
              Keeps track of the Type to LocalBuilder temporary storage created
              to store structures (used to compute the address of the structure
              value on structure method invocations)
            </summary>
        </member>
        <member name="F:Mono.CSharp.EmitContext.return_value">
            <summary>
              The location where we store the return value.
            </summary>
        </member>
        <member name="F:Mono.CSharp.EmitContext.LoopBegin">
            <summary>
              Current loop begin and end labels.
            </summary>
        </member>
        <member name="F:Mono.CSharp.EmitContext.LoopEnd">
            <summary>
              Current loop begin and end labels.
            </summary>
        </member>
        <member name="F:Mono.CSharp.EmitContext.DefaultTarget">
            <summary>
              Default target in a switch statement.   Only valid if
              InSwitch is true
            </summary>
        </member>
        <member name="F:Mono.CSharp.EmitContext.Switch">
            <summary>
              If this is non-null, points to the current switch statement
            </summary>
        </member>
        <member name="F:Mono.CSharp.EmitContext.CurrentAnonymousMethod">
            <summary>
             Whether we are inside an anonymous method.
            </summary>
        </member>
        <member name="M:Mono.CSharp.EmitContext.Mark(Mono.CSharp.Location)">
            <summary>
              This is called immediately before emitting an IL opcode to tell the symbol
              writer to which source line this opcode belongs.
            </summary>
        </member>
        <member name="M:Mono.CSharp.EmitContext.GetTemporaryLocal(Mono.CSharp.TypeSpec)">
            <summary>
              Returns a temporary storage for a variable of type t as 
              a local variable in the current body.
            </summary>
        </member>
        <member name="M:Mono.CSharp.EmitContext.TemporaryReturn">
             <summary>
               ReturnValue creates on demand the LocalBuilder for the
               return value from the function.  By default this is not
               used.  This is only required when returns are found inside
               Try or Catch statements.
            
               This method is typically invoked from the Emit phase, so
               we allow the creation of a return label if it was not
               requested during the resolution phase.   Could be cleaned
               up, but it would replicate a lot of logic in the Emit phase
               of the code that uses it.
             </summary>
        </member>
        <member name="M:Mono.CSharp.Const.Define">
            <summary>
              Defines the constant in the @parent
            </summary>
        </member>
        <member name="M:Mono.CSharp.Const.Emit">
            <summary>
             Emits the field value by evaluating the expression
            </summary>
        </member>
        <member name="T:Mono.CSharp.Constant">
            <summary>
              Base class for constants and literals.
            </summary>
        </member>
        <member name="M:Mono.CSharp.Constant.GetValue">
            <summary>
             This is used to obtain the actual value of the literal
             cast into an object.
            </summary>
        </member>
        <member name="M:Mono.CSharp.Constant.ConvertExplicitly(System.Boolean,Mono.CSharp.TypeSpec)">
            <summary>
            Maybe ConvertTo name is better. It tries to convert `this' constant to target_type.
            It throws OverflowException 
            </summary>
        </member>
        <member name="M:Mono.CSharp.Constant.IsDefaultInitializer(Mono.CSharp.TypeSpec)">
            <summary>
            Need to pass type as the constant can require a boxing
            and in such case no optimization is possible
            </summary>
        </member>
        <member name="M:Mono.CSharp.IntConstant.TryImplicitIntConversion(Mono.CSharp.TypeSpec)">
            <summary>
              Attempts to perform an implicit constant conversion of the IntConstant
              into a different data type using casts (See Implicit Constant
              Expression Conversions)
            </summary>
        </member>
        <member name="T:Mono.CSharp.SideEffectConstant">
            <summary>
              The value is constant, but when emitted has a side effect.  This is
              used by BitwiseAnd to ensure that the second expression is invoked
              regardless of the value of the left side.  
            </summary>
        </member>
        <member name="M:Mono.CSharp.CloneContext.RemapBlockCopy(Mono.CSharp.Block)">
            
             Remaps block to cloned copy if one exists.
            
        </member>
        <member name="M:Mono.CSharp.Convert.ImplicitNumericConversion(Mono.CSharp.Expression,Mono.CSharp.TypeSpec)">
             <summary>
               Implicit Numeric Conversions.
            
               expr is the expression to convert, returns a new expression of type
               target_type or null if an implicit conversion is not possible.
             </summary>
        </member>
        <member name="M:Mono.CSharp.Convert.FindMostEncompassedType(System.Collections.Generic.IList{Mono.CSharp.TypeSpec})">
            <summary>
             Finds "most encompassed type" according to the spec (13.4.2)
             amongst the methods in the MethodGroupExpr
            </summary>
        </member>
        <member name="M:Mono.CSharp.Convert.FindMostSpecificTarget(System.Collections.Generic.IList{Mono.CSharp.MethodSpec},Mono.CSharp.TypeSpec,System.Boolean)">
            <summary>
             Finds the most specific target Tx according to section 13.4.4
            </summary>
        </member>
        <member name="M:Mono.CSharp.Convert.ImplicitUserConversion(Mono.CSharp.ResolveContext,Mono.CSharp.Expression,Mono.CSharp.TypeSpec,Mono.CSharp.Location)">
            <summary>
             User-defined Implicit conversions
            </summary>
        </member>
        <member name="M:Mono.CSharp.Convert.ExplicitUserConversion(Mono.CSharp.ResolveContext,Mono.CSharp.Expression,Mono.CSharp.TypeSpec,Mono.CSharp.Location)">
            <summary>
             User-defined Explicit conversions
            </summary>
        </member>
        <member name="M:Mono.CSharp.Convert.ImplicitConversion(Mono.CSharp.ResolveContext,Mono.CSharp.Expression,Mono.CSharp.TypeSpec,Mono.CSharp.Location)">
            <summary>
              Converts implicitly the resolved expression `expr' into the
              `target_type'.  It returns a new expression that can be used
              in a context that expects a `target_type'.
            </summary>
        </member>
        <member name="M:Mono.CSharp.Convert.ImplicitConversionStandard(Mono.CSharp.ResolveContext,Mono.CSharp.Expression,Mono.CSharp.TypeSpec,Mono.CSharp.Location)">
             <summary>
               Attempts to apply the `Standard Implicit
               Conversion' rules to the expression `expr' into
               the `target_type'.  It returns a new expression
               that can be used in a context that expects a
               `target_type'.
            
               This is different from `ImplicitConversion' in that the
               user defined implicit conversions are excluded.
             </summary>
        </member>
        <member name="M:Mono.CSharp.Convert.ImplicitConversionRequired(Mono.CSharp.ResolveContext,Mono.CSharp.Expression,Mono.CSharp.TypeSpec,Mono.CSharp.Location)">
            <summary>
              Attempts to implicitly convert `source' into `target_type', using
              ImplicitConversion.  If there is no implicit conversion, then
              an error is signaled
            </summary>
        </member>
        <member name="M:Mono.CSharp.Convert.ExplicitNumericConversion(Mono.CSharp.ResolveContext,Mono.CSharp.Expression,Mono.CSharp.TypeSpec)">
             <summary>
               Performs the explicit numeric conversions
            
             There are a few conversions that are not part of the C# standard,
             they were interim hacks in the C# compiler that were supposed to
             become explicit operators in the UIntPtr class and IntPtr class,
             but for historical reasons it did not happen, so the C# compiler
             ended up with these special hacks.
            
             See bug 59800 for details.
            
             The conversion are:
               UIntPtr->SByte
               UIntPtr->Int16
               UIntPtr->Int32
               IntPtr->UInt64
               UInt64->IntPtr
               SByte->UIntPtr
               Int16->UIntPtr
            
             </summary>
        </member>
        <member name="M:Mono.CSharp.Convert.ExplicitReferenceConversionExists(Mono.CSharp.TypeSpec,Mono.CSharp.TypeSpec)">
            <summary>
             Returns whether an explicit reference conversion can be performed
             from source_type to target_type
            </summary>
        </member>
        <member name="M:Mono.CSharp.Convert.ExplicitReferenceConversion(Mono.CSharp.Expression,Mono.CSharp.TypeSpec,Mono.CSharp.TypeSpec)">
            <summary>
              Implements Explicit Reference conversions
            </summary>
        </member>
        <member name="M:Mono.CSharp.Convert.ExplicitConversionCore(Mono.CSharp.ResolveContext,Mono.CSharp.Expression,Mono.CSharp.TypeSpec,Mono.CSharp.Location)">
            <summary>
              Performs an explicit conversion of the expression `expr' whose
              type is expr.Type to `target_type'.
            </summary>
        </member>
        <member name="M:Mono.CSharp.Convert.ExplicitConversionStandard(Mono.CSharp.ResolveContext,Mono.CSharp.Expression,Mono.CSharp.TypeSpec,Mono.CSharp.Location)">
            <summary>
              Same as ExplicitConversion, only it doesn't include user defined conversions
            </summary>
        </member>
        <member name="M:Mono.CSharp.Convert.ExplicitConversion(Mono.CSharp.ResolveContext,Mono.CSharp.Expression,Mono.CSharp.TypeSpec,Mono.CSharp.Location)">
            <summary>
              Performs an explicit conversion of the expression `expr' whose
              type is expr.Type to `target_type'.
            </summary>
        </member>
        <member name="T:Mono.CSharp.CSharpParser">
            <summary>
               The C# Parser
            </summary>
        </member>
        <member name="F:Mono.CSharp.CSharpParser.yyFinal">
            debugging support, requires the package jay.yydebug.
                  Set to null to suppress debugging messages.
        </member>
        <member name="F:Mono.CSharp.CSharpParser.current_block">
            <summary>
              Current block is used to add statements as we find
              them.  
            </summary>
        </member>
        <member name="F:Mono.CSharp.CSharpParser.current_local_parameters">
            <summary>
              This is used by the unary_expression code to resolve
              a name against a parameter.  
            </summary>
        </member>
        <member name="F:Mono.CSharp.CSharpParser.oob_stack">
            
             An out-of-band stack.
            
        </member>
        <member name="F:Mono.CSharp.CSharpParser.yacc_verbose_flag">
            
             Controls the verbosity of the errors produced by the parser
            
        </member>
        <member name="F:Mono.CSharp.CSharpParser.UnexpectedEOF">
             
             Used by the interactive shell, flags whether EOF was reached
             and an error was produced
            
        </member>
        <member name="F:Mono.CSharp.CSharpParser.file">
            
             The current file.
            
        </member>
        <member name="F:Mono.CSharp.CSharpParser.tmpComment">
            
             Temporary Xml documentation cache.
             For enum types, we need one more temporary store.
            
        </member>
        <member name="F:Mono.CSharp.CSharpParser.current_attr_target">
            Current attribute target
        </member>
        <member name="F:Mono.CSharp.CSharpParser.InteractiveResult">
            When using the interactive parser, this holds the
            resulting expression
        </member>
        <member name="F:Mono.CSharp.CSharpParser.ErrorOutput">
            error output stream.
                  It should be changeable.
        </member>
        <member name="M:Mono.CSharp.CSharpParser.yyerror(System.String)">
            simplified error message.
                  @see <a href="#yyerror(java.lang.String, java.lang.String[])">yyerror</a>
        </member>
        <member name="M:Mono.CSharp.CSharpParser.yyerror(System.String,System.String[])">
            (syntax) error message.
                  Can be overwritten to control message format.
                  @param message text to be displayed.
                  @param expected vector of acceptable tokens, if available.
        </member>
        <member name="F:Mono.CSharp.CSharpParser.yyExpectingState">
            index-checked interface to yyNames[].
                  @param token single character or %token value.
                  @return token name or [illegal] or [unknown].
        </member>
        <member name="M:Mono.CSharp.CSharpParser.yyExpectingTokens(System.Int32)">
            computes list of expected tokens on error by tracing the tables.
                  @param state for which to compute the list.
                  @return list of token names.
        </member>
        <member name="M:Mono.CSharp.CSharpParser.yyparse(Mono.CSharp.yyParser.yyInput,System.Object)">
            the generated parser, with debugging messages.
                  Maintains a state and a value stack, currently with fixed maximum size.
                  @param yyLex scanner.
                  @param yydebug debug message writer implementing yyDebug, or null.
                  @return result of the last reduction, if any.
                  @throws yyException on irrecoverable parse error.
        </member>
        <member name="F:Mono.CSharp.CSharpParser.yyMax">
            initial size and increment of the state/value stack [default 256].
                  This is not final so that it can be overwritten outside of invocations
                  of yyparse().
        </member>
        <member name="M:Mono.CSharp.CSharpParser.yyDefault(System.Object)">
            executed at the beginning of a reduce action.
                  Used as $$ = yyDefault($1), prior to the user-specified action, if any.
                  Can be overwritten to provide deep copy, etc.
                  @param first value for $1, or null.
                  @return first.
        </member>
        <member name="M:Mono.CSharp.CSharpParser.yyparse(Mono.CSharp.yyParser.yyInput)">
            the generated parser.
                  Maintains a state and a value stack, currently with fixed maximum size.
                  @param yyLex scanner.
                  @return result of the last reduction, if any.
                  @throws yyException on irrecoverable parse error.
        </member>
        <member name="T:Mono.CSharp.yyParser.yyException">
            thrown for irrecoverable syntax errors and stack overflow.
        </member>
        <member name="T:Mono.CSharp.yyParser.yyInput">
            must be implemented by a scanner object to supply input to the parser.
        </member>
        <member name="M:Mono.CSharp.yyParser.yyInput.advance">
            move on to next token.
                    @return false if positioned beyond tokens.
                    @throws IOException on input error.
        </member>
        <member name="M:Mono.CSharp.yyParser.yyInput.token">
            classifies current token.
                    Should not be called if advance() returned false.
                    @return current %token or single character.
        </member>
        <member name="M:Mono.CSharp.yyParser.yyInput.value">
            associated with current token.
                    Should not be called if advance() returned false.
                    @return value for token().
        </member>
        <member name="T:Mono.CSharp.Tokenizer">
            <summary>
               Tokenizer for C# source code. 
            </summary>
        </member>
        <member name="M:Mono.CSharp.Tokenizer.ParsePragmaDirective(System.String)">
            <summary>
            Handles #pragma directive
            </summary>
        </member>
        <member name="T:Mono.CSharp.Driver">
            <summary>
               The compiler driver.
            </summary>
        </member>
        <member name="T:Mono.CSharp.TypeExpr">
            <summary>
              Expression that evaluates to a type
            </summary>
        </member>
        <member name="T:Mono.CSharp.EnumConstant">
            <summary>
             This class is used to wrap literals which belong inside Enums
            </summary>
        </member>
        <member name="T:Mono.CSharp.ExprClass">
            <remarks>
              The ExprClass class contains the is used to pass the 
              classification of an expression (value, variable, namespace,
              type, method group, property access, event access, indexer access,
              nothing).
            </remarks>
        </member>
        <member name="T:Mono.CSharp.ResolveFlags">
            <remarks>
              This is used to tell Resolve in which types of expressions we're
              interested.
            </remarks>
        </member>
        <member name="T:Mono.CSharp.TypeCast">
             <summary>
               This kind of cast is used to encapsulate the child
               whose type is child.Type into an expression that is
               reported to return "return_type".  This is used to encapsulate
               expressions which have compatible types, but need to be dealt
               at higher levels with.
            
               For example, a "byte" expression could be encapsulated in one
               of these as an "unsigned int".  The type for the expression
               would be "unsigned int".
            
             </summary>
        </member>
        <member name="T:Mono.CSharp.BoxedCast">
             <summary>
               This kind of cast is used to encapsulate Value Types in objects.
            
               The effect of it is to box the value type emitted by the previous
               operation.
             </summary>
        </member>
        <member name="T:Mono.CSharp.ConvCast">
             <summary>
               This is used to perform explicit numeric conversions.
            
               Explicit numeric conversions might trigger exceptions in a checked
               context, so they should generate the conv.ovf opcodes instead of
               conv opcodes.
             </summary>
        </member>
        <member name="T:Mono.CSharp.ClassCast">
            <summary>
              This kind of cast is used to encapsulate a child and cast it
              to the class requested
            </summary>
        </member>
        <member name="T:Mono.CSharp.SimpleName">
            <summary>
              SimpleName expressions are formed of a single word and only happen at the beginning 
              of a dotted-name.
            </summary>
        </member>
        <member name="T:Mono.CSharp.TypeExpression">
            <summary>
              Fully resolved Expression that already evaluated to a type
            </summary>
        </member>
        <member name="T:Mono.CSharp.MethodGroupExpr">
            <summary>
              MethodGroupExpr represents a group of method candidates which
              can be resolved to the best method overload
            </summary>
        </member>
        <member name="M:Mono.CSharp.MethodGroupExpr.OverloadResolve(Mono.CSharp.ResolveContext,Mono.CSharp.Arguments@,Mono.CSharp.OverloadResolver.IErrorHandler,Mono.CSharp.OverloadResolver.Restrictions)">
             <summary>
               Find the Applicable Function Members (7.4.2.1)
            
               me: Method Group expression with the members to select.
                   it might contain constructors or methods (or anything
                   that maps to a method).
            
               Arguments: ArrayList containing resolved Argument objects.
            
               loc: The location if we want an error to be reported, or a Null
                    location for "probing" purposes.
            
               Returns: The MethodBase (either a ConstructorInfo or a MethodInfo)
                        that is the best match of me on Arguments.
            
             </summary>
        </member>
        <member name="T:Mono.CSharp.EventExpr">
            <summary>
              Fully resolved expression that evaluates to an Event
            </summary>
        </member>
        <member name="T:Mono.CSharp.VarExpr">
            
            Handles `var' contextual keyword; var becomes a keyword only
            if no type called var exists in a variable scope
            
        </member>
        <member name="T:Mono.CSharp.Enum">
            <summary>
              Enumeration container
            </summary>
        </member>
        <member name="T:Mono.CSharp.Evaluator">
             <summary>
               Evaluator: provides an API to evaluate C# statements and
               expressions dynamically.
             </summary>
             <remarks>
               This class exposes static methods to evaluate expressions in the
               current program.
            
               To initialize the evaluator with a number of compiler
               options call the Init(string[]args) method with a set of
               command line options that the compiler recognizes.
            
               To interrupt execution of a statement, you can invoke the
               Evaluator.Interrupt method.
             </remarks>
        </member>
        <member name="F:Mono.CSharp.Evaluator.DescribeTypeExpressions">
            <summary>
              If true, turns type expressions into valid expressions
              and calls the describe method on it
            </summary>
        </member>
        <member name="F:Mono.CSharp.Evaluator.Terse">
            <summary>
              Whether the evaluator will use terse syntax, and the semicolons at the end are optional
            </summary>
        </member>
        <member name="M:Mono.CSharp.Evaluator.Interrupt">
            <summary>
              Interrupts the evaluation of an expression executing in Evaluate.
            </summary>
            <remarks>
              Use this method to interrupt long-running invocations.
            </remarks>
        </member>
        <member name="M:Mono.CSharp.Evaluator.Compile(System.String,Mono.CSharp.CompiledMethod@)">
             <summary>
               Compiles the input string and returns a delegate that represents the compiled code.
             </summary>
             <remarks>
            
               Compiles the input string as a C# expression or
               statement, unlike the Evaluate method, the
               resulting delegate can be invoked multiple times
               without incurring in the compilation overhead.
            
               If the return value of this function is null,
               this indicates that the parsing was complete.
               If the return value is a string it indicates
               that the input string was partial and that the
               invoking code should provide more code before
               the code can be successfully compiled.
            
               If you know that you will always get full expressions or
               statements and do not care about partial input, you can use
               the other Compile overload. 
            
               On success, in addition to returning null, the
               compiled parameter will be set to the delegate
               that can be invoked to execute the code.
            
             </remarks>
        </member>
        <member name="M:Mono.CSharp.Evaluator.Compile(System.String)">
             <summary>
               Compiles the input string and returns a delegate that represents the compiled code.
             </summary>
             <remarks>
            
               Compiles the input string as a C# expression or
               statement, unlike the Evaluate method, the
               resulting delegate can be invoked multiple times
               without incurring in the compilation overhead.
            
               This method can only deal with fully formed input
               strings and does not provide a completion mechanism.
               If you must deal with partial input (for example for
               interactive use) use the other overload. 
            
               On success, a delegate is returned that can be used
               to invoke the method.
            
             </remarks>
        </member>
        <member name="M:Mono.CSharp.Evaluator.Evaluate(System.String,System.Object@,System.Boolean@)">
             <summary>
               Evaluates and expression or statement and returns any result values.
             </summary>
             <remarks>
               Evaluates the input string as a C# expression or
               statement.  If the input string is an expression
               the result will be stored in the result variable
               and the result_set variable will be set to true.
            
               It is necessary to use the result/result_set
               pair to identify when a result was set (for
               example, execution of user-provided input can be
               an expression, a statement or others, and
               result_set would only be set if the input was an
               expression.
            
               If the return value of this function is null,
               this indicates that the parsing was complete.
               If the return value is a string, it indicates
               that the input is partial and that the user
               should provide an updated string.
             </remarks>
        </member>
        <member name="M:Mono.CSharp.Evaluator.Run(System.String)">
            <summary>
              Executes the given expression or statement.
            </summary>
            <remarks>
               Executes the provided statement, returns true
               on success, false on parsing errors.  Exceptions
               might be thrown by the called code.
            </remarks>
        </member>
        <member name="M:Mono.CSharp.Evaluator.Evaluate(System.String)">
             <summary>
               Evaluates and expression or statement and returns the result.
             </summary>
             <remarks>
               Evaluates the input string as a C# expression or
               statement and returns the value.   
            
               This method will throw an exception if there is a syntax error,
               of if the provided input is not an expression but a statement.
             </remarks>
        </member>
        <member name="M:Mono.CSharp.Evaluator.LoadAssembly(System.String)">
            <summary>
               Loads the given assembly and exposes the API to the user.
            </summary>
        </member>
        <member name="M:Mono.CSharp.Evaluator.ReferenceAssembly(System.Reflection.Assembly)">
            <summary>
               Exposes the API of the given assembly to the Evaluator
            </summary>
        </member>
        <member name="P:Mono.CSharp.Evaluator.InteractiveBaseClass">
             <summary>
               The base class for the classes that host the user generated code
             </summary>
             <remarks>
            
               This is the base class that will host the code
               executed by the Evaluator.  By default
               this is the Mono.CSharp.InteractiveBase class
               which is useful for interactive use.
            
               By changing this property you can control the
               base class and the static members that are
               available to your evaluated code.
             </remarks>
        </member>
        <member name="T:Mono.CSharp.Evaluator.QuitValue">
            <summary>
              A sentinel value used to indicate that no value was
              was set by the compiled function.   This is used to
              differentiate between a function not returning a
              value and null.
            </summary>
        </member>
        <member name="T:Mono.CSharp.CompiledMethod">
            <summary>
              A delegate that can be used to invoke the
              compiled expression or statement.
            </summary>
            <remarks>
              Since the Compile methods will compile
              statements and expressions into the same
              delegate, you can tell if a value was returned
              by checking whether the returned value is of type
              NoValueSet.   
            </remarks>
        </member>
        <member name="T:Mono.CSharp.InteractiveBase">
            <summary>
              The default base class for every interaction line
            </summary>
            <remarks>
              The expressions and statements behave as if they were
              a static method of this class.   The InteractiveBase class
              contains a number of useful methods, but can be overwritten
              by setting the InteractiveBaseType property in the Evaluator
            </remarks>
        </member>
        <member name="F:Mono.CSharp.InteractiveBase.Output">
            <summary>
              Determines where the standard output of methods in this class will go. 
            </summary>
        </member>
        <member name="F:Mono.CSharp.InteractiveBase.Error">
            <summary>
              Determines where the standard error of methods in this class will go. 
            </summary>
        </member>
        <member name="F:Mono.CSharp.InteractiveBase.Prompt">
            <summary>
              The primary prompt used for interactive use.
            </summary>
        </member>
        <member name="F:Mono.CSharp.InteractiveBase.ContinuationPrompt">
            <summary>
              The secondary prompt used for interactive use (used when
              an expression is incomplete).
            </summary>
        </member>
        <member name="F:Mono.CSharp.InteractiveBase.QuitRequested">
            <summary>
              Used to signal that the user has invoked the  `quit' statement.
            </summary>
        </member>
        <member name="M:Mono.CSharp.InteractiveBase.ShowVars">
            <summary>
              Shows all the variables defined so far.
            </summary>
        </member>
        <member name="M:Mono.CSharp.InteractiveBase.ShowUsing">
            <summary>
              Displays the using statements in effect at this point. 
            </summary>
        </member>
        <member name="M:Mono.CSharp.InteractiveBase.Time(System.Action)">
            <summary>
              Times the execution of the given delegate
            </summary>
        </member>
        <member name="M:Mono.CSharp.InteractiveBase.LoadPackage(System.String)">
            <summary>
              Loads the assemblies from a package
            </summary>
            <remarks>
              Loads the assemblies from a package.   This is equivalent
              to passing the -pkg: command line flag to the C# compiler
              on the command line. 
            </remarks>
        </member>
        <member name="M:Mono.CSharp.InteractiveBase.LoadAssembly(System.String)">
            <summary>
              Loads the assembly
            </summary>
            <remarks>
              Loads the specified assembly and makes its types
              available to the evaluator.  This is equivalent
              to passing the -pkg: command line flag to the C#
              compiler on the command line.
            </remarks>
        </member>
        <member name="M:Mono.CSharp.InteractiveBase.Quit">
            <summary>
              Same as quit - useful in script scenerios
            </summary>
        </member>
        <member name="M:Mono.CSharp.InteractiveBase.Describe(System.Object)">
            <summary>
              Describes an object or a type.
            </summary>
            <remarks>
              This method will show a textual representation
              of the object's type.  If the object is a
              System.Type it renders the type directly,
              otherwise it renders the type returned by
              invoking GetType on the object.
            </remarks>
        </member>
        <member name="P:Mono.CSharp.InteractiveBase.help">
            <summary>
              Returns a list of available static methods. 
            </summary>
        </member>
        <member name="P:Mono.CSharp.InteractiveBase.quit">
            <summary>
              Indicates to the read-eval-print-loop that the interaction should be finished. 
            </summary>
        </member>
        <member name="T:Mono.CSharp.OptionalAssign">
             <summary>
                A class used to assign values if the source expression is not void
            
                Used by the interactive shell to allow it to call this code to set
                the return value for an invocation.
             </summary>
        </member>
        <member name="T:Mono.CSharp.UnaryMutator">
             <summary>
               Unary Mutator expressions (pre and post ++ and --)
             </summary>
            
             <remarks>
               UnaryMutator implements ++ and -- expressions.   It derives from
               ExpressionStatement becuase the pre/post increment/decrement
               operators can be used in a statement context.
            
             FIXME: Idea, we could split this up in two classes, one simpler
             for the common case, and one with the extra fields for more complex
             classes (indexers require temporary access;  overloaded require method)
            
             </remarks>
        </member>
        <member name="T:Mono.CSharp.Is">
            <summary>
              Implementation of the `is' operator.
            </summary>
        </member>
        <member name="T:Mono.CSharp.As">
            <summary>
              Implementation of the `as' operator.
            </summary>
        </member>
        <member name="T:Mono.CSharp.Binary">
            <summary>
              Binary operators
            </summary>
        </member>
        <member name="M:Mono.CSharp.Binary.OperName(Mono.CSharp.Binary.Operator)">
            <summary>
              Returns a stringified representation of the Operator
            </summary>
        </member>
        <member name="M:Mono.CSharp.Binary.EmitBranchable(Mono.CSharp.EmitContext,System.Reflection.Emit.Label,System.Boolean)">
             <remarks>
               EmitBranchable is called from Statement.EmitBoolExpression in the
               context of a conditional bool expression.  This function will return
               false if it is was possible to use EmitBranchable, or true if it was.
            
               The expression's code is generated, and we will generate a branch to `target'
               if the resulting expression value is equal to isTrue
             </remarks>
        </member>
        <member name="T:Mono.CSharp.Conditional">
            <summary>
              Implements the ternary conditional operator (?:)
            </summary>
        </member>
        <member name="T:Mono.CSharp.ParameterReference">
            <summary>
              This represents a reference to a parameter in the intermediate
              representation.
            </summary>
        </member>
        <member name="M:Mono.CSharp.New.Constantify(Mono.CSharp.TypeSpec,Mono.CSharp.Location)">
            <summary>
            Converts complex core type syntax like 'new int ()' to simple constant
            </summary>
        </member>
        <member name="T:Mono.CSharp.ArrayCreation">
             <summary>
               14.5.10.2: Represents an array creation expression.
             </summary>
            
             <remarks>
               There are two possible scenarios here: one is an array creation
               expression that specifies the dimensions and optionally the
               initialization data and the other which does not need dimensions
               specified but where initialization data is mandatory.
             </remarks>
        </member>
        <member name="T:Mono.CSharp.This">
            <summary>
              Represents the `this' construct
            </summary>
        </member>
        <member name="T:Mono.CSharp.ArglistAccess">
            <summary>
              Represents the `__arglist' construct
            </summary>
        </member>
        <member name="T:Mono.CSharp.Arglist">
            <summary>
              Represents the `__arglist (....)' construct
            </summary>
        </member>
        <member name="T:Mono.CSharp.TypeOf">
            <summary>
              Implements the typeof operator
            </summary>
        </member>
        <member name="T:Mono.CSharp.SizeOf">
            <summary>
              Implements the sizeof expression
            </summary>
        </member>
        <member name="T:Mono.CSharp.QualifiedAliasMember">
            <summary>
              Implements the qualified-alias-member (::) expression.
            </summary>
        </member>
        <member name="T:Mono.CSharp.CheckedExpr">
            <summary>
              Implements checked expressions
            </summary>
        </member>
        <member name="T:Mono.CSharp.UnCheckedExpr">
            <summary>
              Implements the unchecked expression
            </summary>
        </member>
        <member name="T:Mono.CSharp.ElementAccess">
             <summary>
               An Element Access expression.
            
               During semantic analysis these are transformed into 
               IndexerAccess, ArrayAccess or a PointerArithmetic.
             </summary>
        </member>
        <member name="T:Mono.CSharp.ArrayAccess">
            <summary>
              Implements array access 
            </summary>
        </member>
        <member name="T:Mono.CSharp.EmptyExpression">
             <summary>
               This class exists solely to pass the Type around and to be a dummy
               that can be passed to the conversion functions (this is used by
               foreach implementation to typecast the object return value from
               get_Current into the proper type.  All code has been generated and
               we only care about the side effect conversions to be performed
            
               This is also now used as a placeholder where a no-action expression
               is needed (the `New' class).
             </summary>
        </member>
        <member name="T:Mono.CSharp.FixedField">
            <summary>
            Fixed buffer implementation
            </summary>
        </member>
        <member name="T:Mono.CSharp.TypeParameterExpr">
            <summary>
              A TypeExpr which already resolved to a type parameter.
            </summary>
        </member>
        <member name="M:Mono.CSharp.TypeArguments.Resolve(Mono.CSharp.IMemberContext)">
            <summary>
              Resolve the type arguments.
            </summary>
        </member>
        <member name="P:Mono.CSharp.TypeArguments.Arguments">
            <summary>
              We may only be used after Resolve() is called and return the fully
              resolved types.
            </summary>
        </member>
        <member name="M:Mono.CSharp.GenericTypeExpr.#ctor(Mono.CSharp.TypeSpec,Mono.CSharp.TypeArguments,Mono.CSharp.Location)">
            <summary>
              Instantiate the generic type `t' with the type arguments `args'.
              Use this constructor if you already know the fully resolved
              generic type.
            </summary>		
        </member>
        <member name="M:Mono.CSharp.TypeManager.CSharpName(Mono.CSharp.TypeSpec)">
            <summary>
              Returns the C# name of a type if possible, or the full type name otherwise
            </summary>
        </member>
        <member name="M:Mono.CSharp.TypeManager.HasElementType(Mono.CSharp.TypeSpec)">
            <summary>
            This method is not implemented by MS runtime for dynamic types
            </summary>
        </member>
        <member name="M:Mono.CSharp.TypeManager.VerifyUnmanaged(Mono.CSharp.ModuleContainer,Mono.CSharp.TypeSpec,Mono.CSharp.Location)">
            <summary>
              Utility function that can be used to probe whether a type
              is managed or not.  
            </summary>
        </member>
        <member name="M:Mono.CSharp.TypeManager.IsInstantiationOfSameGenericType(Mono.CSharp.TypeSpec,Mono.CSharp.TypeSpec)">
            <summary>
              Check whether `type' and `parent' are both instantiations of the same
              generic type.  Note that we do not check the type parameters here.
            </summary>
        </member>
        <member name="T:Mono.CSharp.Return">
            <summary>
              Implements the return statement
            </summary>
        </member>
        <member name="T:Mono.CSharp.Block">
             <summary>
               Block represents a C# block.
             </summary>
            
             <remarks>
               This class is used in a number of places: either to represent
               explicit blocks that the programmer places or implicit blocks.
            
               Implicit blocks are used as labels or to introduce variable
               declarations.
            
               Top-level blocks derive from Block, and they are called ToplevelBlock
               they contain extra information that is not necessary on normal blocks.
             </remarks>
        </member>
        <member name="T:Mono.CSharp.ParameterBase">
            <summary>
              Abstract Base class for parameters of a method.
            </summary>
        </member>
        <member name="T:Mono.CSharp.Location">
             <summary>
               Keeps track of the location in the program
             </summary>
            
             <remarks>
               This uses a compact representation and a couple of auxiliary
               structures to keep track of tokens to (file,line and column) 
               mappings. The usage of the bits is:
               
                 - 16 bits for "checkpoint" which is a mixed concept of
                   file and "line segment"
                 - 8 bits for line delta (offset) from the line segment
                 - 8 bits for column number.
            
               http://lists.ximian.com/pipermail/mono-devel-list/2004-December/009508.html
             </remarks>
        </member>
        <member name="P:Mono.CSharp.Location.IsNull">
            <summary>
              Whether the Location is Null
            </summary>
        </member>
        <member name="M:Mono.CSharp.MethodData.DefineMethodBuilder(Mono.CSharp.TypeDefinition,System.String,Mono.CSharp.ParametersCompiled)">
            <summary>
            Create the MethodBuilder for the method 
            </summary>
        </member>
        <member name="M:Mono.CSharp.Namespace.#ctor(Mono.CSharp.Namespace,System.String)">
            <summary>
              Constructor Takes the current namespace and the
              name.  This is bootstrapped with parent == null
              and name = ""
            </summary>
        </member>
        <member name="P:Mono.CSharp.Namespace.Name">
            <summary>
              The qualified name of the current namespace
            </summary>
        </member>
        <member name="P:Mono.CSharp.Namespace.Parent">
            <summary>
              The parent of this namespace, used by the parser to "Pop"
              the current namespace declaration
            </summary>
        </member>
        <member name="T:Mono.CSharp.ReturnParameter">
            <summary>
            Class for applying custom attributes on the return type
            </summary>
        </member>
        <member name="P:Mono.CSharp.ReturnParameter.ValidAttributeTargets">
            <summary>
            Is never called
            </summary>
        </member>
        <member name="T:Mono.CSharp.ParametersCompiled">
            <summary>
              Represents the methods parameters
            </summary>
        </member>
        <member name="F:Mono.CSharp.PendingImplementation.container">
            <summary>
              The container for this PendingImplementation
            </summary>
        </member>
        <member name="F:Mono.CSharp.PendingImplementation.pending_implementations">
            <summary>
              This is the array of TypeAndMethods that describes the pending implementations
              (both interfaces and abstract methods in base class)
            </summary>
        </member>
        <member name="M:Mono.CSharp.PendingImplementation.IsInterfaceMethod(Mono.CSharp.MemberName,Mono.CSharp.TypeSpec,Mono.CSharp.MethodData,Mono.CSharp.MethodSpec@,System.Boolean@)">
            <summary>
              Whether the specified method is an interface method implementation
            </summary>
        </member>
        <member name="M:Mono.CSharp.PendingImplementation.InterfaceMethod(Mono.CSharp.MemberName,Mono.CSharp.TypeSpec,Mono.CSharp.MethodData,Mono.CSharp.PendingImplementation.Operation,Mono.CSharp.MethodSpec@,System.Boolean@)">
             <remarks>
               If a method in Type `t' (or null to look in all interfaces
               and the base abstract class) with name `Name', return type `ret_type' and
               arguments `args' implements an interface, this method will
               return the MethodInfo that this method implements.
            
               If `name' is null, we operate solely on the method's signature.  This is for
               instance used when implementing indexers.
            
               The `Operation op' controls whether to lookup, clear the pending bit, or clear
               all the methods with the given signature.
            
               The `MethodInfo need_proxy' is used when we're implementing an interface's
               indexer in a class.  If the new indexer's IndexerName does not match the one
               that was used in the interface, then we always need to create a proxy for it.
            
             </remarks>
        </member>
        <member name="M:Mono.CSharp.PendingImplementation.DefineProxy(Mono.CSharp.TypeSpec,Mono.CSharp.MethodSpec,Mono.CSharp.MethodSpec)">
             <summary>
               C# allows this kind of scenarios:
               interface I { void M (); }
               class X { public void M (); }
               class Y : X, I { }
            
               For that case, we create an explicit implementation function
               I.M in Y.
             </summary>
        </member>
        <member name="M:Mono.CSharp.PendingImplementation.BaseImplements(Mono.CSharp.TypeSpec,Mono.CSharp.MethodSpec,Mono.CSharp.MethodSpec@)">
            <summary>
              This function tells whether one of our base classes implements
              the given method (which turns out, it is valid to have an interface
              implementation in a base
            </summary>
        </member>
        <member name="M:Mono.CSharp.PendingImplementation.VerifyPendingMethods">
            <summary>
              Verifies that any pending abstract methods or interface methods
              were implemented.
            </summary>
        </member>
        <member name="T:Mono.CSharp.EventProperty">
            <summary>
            For case when event is declared like property (with add and remove accessors).
            </summary>
        </member>
        <member name="T:Mono.CSharp.EventField">
            <summary>
            Event is declared like field.
            </summary>
        </member>
        <member name="F:Mono.CSharp.Report.extra_information">
            <summary>
            List of symbols related to reported error/warning. You have to fill it before error/warning is reported.
            </summary>
        </member>
        <member name="M:Mono.CSharp.Report.SymbolRelatedToPreviousError(Mono.CSharp.Location,System.String)">
            <summary>
            In most error cases is very useful to have information about symbol that caused the error.
            Call this method before you call Report.Error when it makes sense.
            </summary>
        </member>
        <member name="T:Mono.CSharp.WarningRegions">
            <summary>
            Handles #pragma warning
            </summary>
        </member>
        <member name="T:Mono.CSharp.GotoDefault">
            <summary>
              `goto default' statement
            </summary>
        </member>
        <member name="T:Mono.CSharp.GotoCase">
            <summary>
              `goto case' statement
            </summary>
        </member>
        <member name="F:Mono.CSharp.Switch.SwitchType">
            <summary>
              The governing switch type
            </summary>
        </member>
        <member name="T:Mono.CSharp.Foreach">
            <summary>
              Implementation of the foreach C# statement
            </summary>
        </member>
        <member name="T:Mono.CSharp.CompletionResult">
            <summary>
              An exception used to terminate the compiler resolution phase and provide completions
            </summary>
            <remarks>
              This is thrown when we want to return the completions or
              terminate the completion process by AST nodes used in
              the completion process.
            </remarks>
        </member>
        <member name="M:Mono.CSharp.TypeSpecComparer.Unify.MayBecomeEqualGenericTypes(Mono.CSharp.TypeSpec,Mono.CSharp.TypeSpec)">
            <summary>
              Check whether `a' and `b' may become equal generic types.
              The algorithm to do that is a little bit complicated.
            </summary>
        </member>
        <member name="P:ICSharpCode.NRefactory.CSharp.QueryExpressionExpansionResult.RangeVariables">
            <summary>
            Maps original range variables to some node in the new tree that represents them.
            </summary>
        </member>
        <member name="P:ICSharpCode.NRefactory.CSharp.QueryExpressionExpansionResult.Expressions">
            <summary>
            Maps clauses to method calls. The keys will always be either a <see cref="T:ICSharpCode.NRefactory.CSharp.QueryClause"/> or a <see cref="T:ICSharpCode.NRefactory.CSharp.QueryOrdering"/>
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.QueryExpressionExpander.ExpandQueryExpressions(ICSharpCode.NRefactory.CSharp.AstNode)">
            <summary>
            Expands all occurances of query patterns in the specified node. Returns a clone of the node with all query patterns expanded, or null if there was no query pattern to expand.
            </summary>
            <param name="node"></param>
            <returns></returns>
        </member>
        <member name="T:ICSharpCode.NRefactory.CSharp.Refactoring.AddUsingAction">
            <summary>
            1) When a type cannot be resolved, offers to add a using declaration
            or to replace it with the fully qualified type name.
            2) When an extension method cannot be resolved, offers to add a using declaration.
            3) When the caret is on a namespace name, offers to add a using declaration
            and simplify the type references to use the new shorter option.
            </summary>
        </member>
        <member name="T:ICSharpCode.NRefactory.CSharp.Refactoring.ConvertAsToCastAction">
            <summary>
            Converts an 'as' expression to a cast expression
            </summary>
        </member>
        <member name="T:ICSharpCode.NRefactory.CSharp.Refactoring.SpecializedCodeAction`1">
            <summary>
            A specialized code action creates a code action assoziated with one special type of ast nodes.
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.Refactoring.SpecializedCodeAction`1.GetAction(ICSharpCode.NRefactory.CSharp.Refactoring.RefactoringContext,`0)">
            <summary>
            Gets the action for the specified ast node.
            </summary>
            <returns>
            The code action. May return <c>null</c>, if no action can be provided.
            </returns>
            <param name='context'>
            The refactoring conext.
            </param>
            <param name='node'>
            The AstNode it's ensured that the node is always != null, if called.
            </param>
        </member>
        <member name="T:ICSharpCode.NRefactory.CSharp.Refactoring.ConvertCastToAsAction">
            <summary>
            Converts a cast expression to an 'as' expression
            </summary>
        </member>
        <member name="T:ICSharpCode.NRefactory.CSharp.Refactoring.ICodeIssueProvider">
            <summary>
            The code issue provider gets a list of all code issues in a syntax tree.
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.Refactoring.ICodeIssueProvider.GetIssues(ICSharpCode.NRefactory.CSharp.Refactoring.BaseRefactoringContext)">
            <summary>
            Gets all code issues inside a syntax tree.
            </summary>
            <param name='context'>
            The refactoring context of the issues to get.
            </param>
        </member>
        <member name="T:ICSharpCode.NRefactory.CSharp.GatherVisitorBase">
            <summary>
            A base class for writing issue provider visitor implementations.
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.GatherVisitorBase.#ctor(ICSharpCode.NRefactory.CSharp.Refactoring.BaseRefactoringContext)">
            <summary>
            Initializes a new instance of the <see cref="T:ICSharpCode.NRefactory.CSharp.GatherVisitorBase"/> class.
            </summary>
            <param name="ctx">
            The refactoring context.
            </param>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.GatherVisitorBase.GetIssues">
            <summary>
            Gets all the issues using the context root node as base.
            </summary>
            <returns>
            The issues.
            </returns>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.Refactoring.MultipleEnumerationIssue.GatherVisitor.SplitNode(ICSharpCode.NRefactory.CSharp.Refactoring.VariableReferenceNode)">
            <summary>
            split references in the specified node into sub nodes according to the value they uses
            </summary>
            <param name="node">node to split</param>
            <returns>list of sub nodes</returns>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.Refactoring.MultipleEnumerationIssue.GatherVisitor.GetAssignmentUsageGraph(ICSharpCode.NRefactory.CSharp.Refactoring.VariableReferenceNode)">
            <summary>
            convert a variable reference graph starting from the specified node to an assignment usage graph,
            in which nodes are connect if and only if they contains references using the same assigned value
            </summary>
            <param name="startNode">starting node of the variable reference graph</param>
            <returns>
            list of VariableReferenceNode, each of which is a starting node of a sub-graph in which references all
            use the same assigned value
            </returns>
        </member>
        <member name="T:ICSharpCode.NRefactory.CSharp.Refactoring.DocumentScript">
            <summary>
            Script implementation based on IDocument.
            </summary>
        </member>
        <member name="T:ICSharpCode.NRefactory.CSharp.Refactoring.Script">
            <summary>
            Class for creating change scripts.
            'Original document' = document without the change script applied.
            'Current document' = document with the change script (as far as it is already created) applies.
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.Refactoring.Script.GetCurrentOffset(System.Int32)">
            <summary>
            Given an offset in the original document (at the start of script execution),
            returns the offset in the current document.
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.Refactoring.Script.GetCurrentOffset(ICSharpCode.NRefactory.TextLocation)">
            <summary>
            Given an offset in the original document (at the start of script execution),
            returns the offset in the current document.
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.Refactoring.Script.CreateTrackedSegment(System.Int32,System.Int32)">
            <summary>
            Creates a tracked segment for the specified (offset,length)-segment.
            Offset is interpreted to be an offset in the current document.
            </summary>
            <returns>
            A segment that initially has the specified values, and updates
            on every <see cref="M:ICSharpCode.NRefactory.CSharp.Refactoring.Script.Replace(System.Int32,System.Int32,System.String)"/> call.
            </returns>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.Refactoring.Script.Replace(System.Int32,System.Int32,System.String)">
            <summary>
            Replaces text.
            </summary>
            <param name="offset">The starting offset of the text to be replaced.</param>
            <param name="length">The length of the text to be replaced.</param>
            <param name="newText">The new text.</param>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.Refactoring.Script.Rename(ICSharpCode.NRefactory.TypeSystem.IEntity,System.String)">
            <summary>
            Renames the specified entity.
            </summary>
            <param name='entity'>
            The Entity to rename
            </param>
            <param name='name'>
            The new name, if null the user is prompted for a new name.
            </param>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.Refactoring.Script.RenameTypeParameter(ICSharpCode.NRefactory.TypeSystem.IType,System.String)">
            <summary>
            Renames the specified entity.
            </summary>
            <param name='type'>
            The Entity to rename
            </param>
            <param name='name'>
            The new name, if null the user is prompted for a new name.
            </param>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.Refactoring.Script.Rename(ICSharpCode.NRefactory.TypeSystem.IVariable,System.String)">
            <summary>
            Renames the specified variable.
            </summary>
            <param name='variable'>
            The Variable to rename
            </param>
            <param name='name'>
            The new name, if null the user is prompted for a new name.
            </param>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.Refactoring.Script.CreateNewType(ICSharpCode.NRefactory.CSharp.AstNode,ICSharpCode.NRefactory.CSharp.Refactoring.Script.NewTypeContext)">
            <summary>
            Creates a new file containing the type, namespace and correct usings.
            (Note: Should take care of IDE specific things, file headers, add to project, correct name).
            </summary>
            <param name='newType'>
            New type to be created.
            </param>
            <param name='context'>
            The Context in which the new type should be created.
            </param>
        </member>
        <member name="F:ICSharpCode.NRefactory.CSharp.Refactoring.Script.NewTypeContext.CurrentNamespace">
            <summary>
            The class should be placed in a new file to the current namespace.
            </summary>
        </member>
        <member name="F:ICSharpCode.NRefactory.CSharp.Refactoring.Script.NewTypeContext.UnitTests">
            <summary>
            The class should be placed in the unit tests. (not implemented atm.)
            </summary>
        </member>
        <member name="T:ICSharpCode.NRefactory.CSharp.Refactoring.UsingHelper">
            <summary>
            Helper methods for managing using declarations.
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.Refactoring.UsingHelper.InsertUsingAndRemoveRedundantNamespaceUsage(ICSharpCode.NRefactory.CSharp.Refactoring.RefactoringContext,ICSharpCode.NRefactory.CSharp.Refactoring.Script,System.String)">
            <summary>
            Inserts 'using ns;' in the current scope, and then removes all explicit
            usages of ns that were made redundant by the new using.
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.Refactoring.UsingHelper.InsertUsing(ICSharpCode.NRefactory.CSharp.Refactoring.RefactoringContext,ICSharpCode.NRefactory.CSharp.Refactoring.Script,ICSharpCode.NRefactory.CSharp.AstNode)">
            <summary>
            Inserts 'newUsing' in the current scope.
            This method will try to insert new usings in the correct position (depending on
            where the existing usings are; and maintaining the sort order).
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.Refactoring.UsingHelper.SortUsingBlock(System.Collections.Generic.IEnumerable{ICSharpCode.NRefactory.CSharp.AstNode},ICSharpCode.NRefactory.CSharp.Refactoring.BaseRefactoringContext)">
            <summary>
            Sorts the specified usings.
            </summary>
        </member>
        <member name="T:ICSharpCode.NRefactory.CSharp.Refactoring.PatternHelper">
            <summary>
            Helper class for constructing pattern ASTs.
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.Refactoring.PatternHelper.CommutativeOperator(ICSharpCode.NRefactory.CSharp.Expression,ICSharpCode.NRefactory.CSharp.BinaryOperatorType,ICSharpCode.NRefactory.CSharp.Expression)">
            <summary>
            Produces a choice pattern for <c>expr1 op expr2</c> or <c>expr2 op expr1</c>.
            </summary>
        </member>
        <member name="T:ICSharpCode.NRefactory.CSharp.Refactoring.RefactoringAstHelper">
            <summary>
            Helper methods for constructing ASTs for refactoring.
            These helpers work with frozen ASTs, i.e. they clone input nodes.
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.Refactoring.RefactoringAstHelper.RemoveTarget(ICSharpCode.NRefactory.CSharp.MemberReferenceExpression)">
            <summary>
            Removes the target from a member reference while preserving the identifier and type arguments.
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.Refactoring.RefactoringAstHelper.RemoveTarget(ICSharpCode.NRefactory.CSharp.MemberType)">
            <summary>
            Removes the target from a member reference while preserving the identifier and type arguments.
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.Refactoring.BaseRefactoringContext.CreateDefiniteAssignmentAnalysis(ICSharpCode.NRefactory.CSharp.Statement)">
            <summary>
            Creates a new definite assignment analysis object with a given root statement.
            </summary>
            <returns>
            The definite assignment analysis object.
            </returns>
            <param name='root'>
            The root statement.
            </param>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.Refactoring.BaseRefactoringContext.CreateReachabilityAnalysis(ICSharpCode.NRefactory.CSharp.Statement)">
            <summary>
            Creates a new reachability analysis object with a given statement.
            </summary>
            <param name="statement">
            The statement to start the analysis.
            </param>
            <returns>
            The reachability analysis object.
            </returns>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.Refactoring.BaseRefactoringContext.ParseFormatString(System.String)">
            <summary>
            Parses a composite format string.
            </summary>
            <returns>
            The format string parsing result.
            </returns>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.Refactoring.BaseRefactoringContext.TranslateString(System.String)">
            <summary>
            Translates the english input string to the context language.
            </summary>
            <returns>
            The translated string.
            </returns>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.Refactoring.BaseRefactoringContext.GetService(System.Type)">
            <summary>
            Retrieves a service from the refactoring context.
            If the service is not found in the <see cref="P:ICSharpCode.NRefactory.CSharp.Refactoring.BaseRefactoringContext.Services"/> container.
            </summary>
        </member>
        <member name="P:ICSharpCode.NRefactory.CSharp.Refactoring.BaseRefactoringContext.UseExplicitTypes">
            <summary>
            Gets a value indicating if 'var' keyword should be used or explicit types.
            </summary>
        </member>
        <member name="P:ICSharpCode.NRefactory.CSharp.Refactoring.BaseRefactoringContext.Services">
            <summary>
            Gets a service container used to associate services with this context.
            </summary>
        </member>
        <member name="T:ICSharpCode.NRefactory.CSharp.Refactoring.TypeSystemAstBuilder">
            <summary>
            Converts from type system to the C# AST.
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.Refactoring.TypeSystemAstBuilder.#ctor(ICSharpCode.NRefactory.CSharp.Resolver.CSharpResolver)">
            <summary>
            Creates a new TypeSystemAstBuilder.
            </summary>
            <param name="resolver">
            A resolver initialized for the position where the type will be inserted.
            </param>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.Refactoring.TypeSystemAstBuilder.#ctor">
            <summary>
            Creates a new TypeSystemAstBuilder.
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.Refactoring.TypeSystemAstBuilder.TypeMatches(ICSharpCode.NRefactory.TypeSystem.IType,ICSharpCode.NRefactory.TypeSystem.ITypeDefinition,System.Collections.Generic.IList{ICSharpCode.NRefactory.TypeSystem.IType})">
            <summary>
            Gets whether 'type' is the same as 'typeDef' parameterized with the given type arguments.
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.Refactoring.TypeSystemAstBuilder.AddTypeArguments(ICSharpCode.NRefactory.CSharp.AstType,ICSharpCode.NRefactory.TypeSystem.ITypeDefinition,System.Collections.Generic.IList{ICSharpCode.NRefactory.TypeSystem.IType},System.Int32,System.Int32)">
            <summary>
            Adds type arguments to the result type.
            </summary>
            <param name="result">The result AST node (a SimpleType or MemberType)</param>
            <param name="typeDef">The type definition that owns the type parameters</param>
            <param name="typeArguments">The list of type arguments</param>
            <param name="startIndex">Index of first type argument to add</param>
            <param name="endIndex">Index after last type argument to add</param>
        </member>
        <member name="P:ICSharpCode.NRefactory.CSharp.Refactoring.TypeSystemAstBuilder.AddAnnotations">
            <summary>
            Specifies whether the ast builder should add annotations to type references.
            The default value is <c>false</c>.
            </summary>
        </member>
        <member name="P:ICSharpCode.NRefactory.CSharp.Refactoring.TypeSystemAstBuilder.ShowAccessibility">
            <summary>
            Controls the accessibility modifiers are shown.
            The default value is <c>true</c>.
            </summary>
        </member>
        <member name="P:ICSharpCode.NRefactory.CSharp.Refactoring.TypeSystemAstBuilder.ShowModifiers">
            <summary>
            Controls the non-accessibility modifiers are shown.
            The default value is <c>true</c>.
            </summary>
        </member>
        <member name="P:ICSharpCode.NRefactory.CSharp.Refactoring.TypeSystemAstBuilder.ShowBaseTypes">
            <summary>
            Controls whether base type references are shown.
            The default value is <c>true</c>.
            </summary>
        </member>
        <member name="P:ICSharpCode.NRefactory.CSharp.Refactoring.TypeSystemAstBuilder.ShowTypeParameters">
            <summary>
            Controls whether type parameter declarations are shown.
            The default value is <c>true</c>.
            </summary>
        </member>
        <member name="P:ICSharpCode.NRefactory.CSharp.Refactoring.TypeSystemAstBuilder.ShowTypeParameterConstraints">
            <summary>
            Controls whether constraints on type parameter declarations are shown.
            Has no effect if ShowTypeParameters is false.
            The default value is <c>true</c>.
            </summary>
        </member>
        <member name="P:ICSharpCode.NRefactory.CSharp.Refactoring.TypeSystemAstBuilder.ShowParameterNames">
            <summary>
            Controls whether the names of parameters are shown.
            The default value is <c>true</c>.
            </summary>
        </member>
        <member name="P:ICSharpCode.NRefactory.CSharp.Refactoring.TypeSystemAstBuilder.ShowConstantValues">
            <summary>
            Controls whether to show default values of optional parameters, and the values of constant fields.
            The default value is <c>true</c>.
            </summary>
        </member>
        <member name="P:ICSharpCode.NRefactory.CSharp.Refactoring.TypeSystemAstBuilder.AlwaysUseShortTypeNames">
            <summary>
            Controls whether to use fully-qualified type names or short type names.
            The default value is <c>false</c>.
            </summary>
        </member>
        <member name="P:ICSharpCode.NRefactory.CSharp.Refactoring.TypeSystemAstBuilder.GenerateBody">
            <summary>
            Controls whether to generate a body that throws a <c>System.NotImplementedException</c>.
            The default value is <c>false</c>.
            </summary>
        </member>
        <member name="P:ICSharpCode.NRefactory.CSharp.Refactoring.TypeSystemAstBuilder.UseCustomEvents">
            <summary>
            Controls whether to generate custom events.
            The default value is <c>false</c>.
            </summary>
        </member>
        <member name="P:ICSharpCode.NRefactory.CSharp.Refactoring.TypeSystemAstBuilder.ConvertUnboundTypeArguments">
            <summary>
            Controls if unbound type argument names are inserted in the ast or not.
            The default value is <c>false</c>.
            </summary>
        </member>
        <member name="P:ICSharpCode.NRefactory.CSharp.Refactoring.TypeSystemAstBuilder.UseAliases">
            <summary>
            Controls if aliases should be used inside the type name or not.
            The default value is <c>true</c>.
            </summary>
        </member>
        <member name="T:ICSharpCode.NRefactory.CSharp.Resolver.IResolveVisitorNavigator">
            <summary>
            Allows controlling which nodes are resolved by the resolve visitor.
            </summary>
            <seealso cref="T:ICSharpCode.NRefactory.CSharp.Resolver.ResolveVisitor"/>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.Resolver.IResolveVisitorNavigator.Scan(ICSharpCode.NRefactory.CSharp.AstNode)">
            <summary>
            Asks the navigator whether to scan, skip, or resolve a node.
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.Resolver.IResolveVisitorNavigator.Resolved(ICSharpCode.NRefactory.CSharp.AstNode,ICSharpCode.NRefactory.Semantics.ResolveResult)">
            <summary>
            Notifies the navigator that a node was resolved.
            </summary>
            <param name="node">The node that was resolved</param>
            <param name="result">Resolve result</param>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.Resolver.IResolveVisitorNavigator.ProcessConversion(ICSharpCode.NRefactory.CSharp.Expression,ICSharpCode.NRefactory.Semantics.ResolveResult,ICSharpCode.NRefactory.Semantics.Conversion,ICSharpCode.NRefactory.TypeSystem.IType)">
            <summary>
            Notifies the navigator that a conversion was applied.
            </summary>
            <param name="expression">The expression that was resolved.</param>
            <param name="result">The resolve result of the expression.</param>
            <param name="conversion">The conversion applied to the expressed.</param>
            <param name="targetType">The target type of the conversion.</param>
        </member>
        <member name="T:ICSharpCode.NRefactory.CSharp.Resolver.AwaitResolveResult">
            <summary>
            Represents the result of an await expression.
            </summary>
        </member>
        <member name="F:ICSharpCode.NRefactory.CSharp.Resolver.AwaitResolveResult.GetAwaiterInvocation">
            <summary>
            The method representing the GetAwaiter() call. Can be an <see cref="T:ICSharpCode.NRefactory.Semantics.InvocationResolveResult"/> or a <see cref="T:ICSharpCode.NRefactory.CSharp.Resolver.DynamicInvocationResolveResult"/>.
            </summary>
        </member>
        <member name="F:ICSharpCode.NRefactory.CSharp.Resolver.AwaitResolveResult.AwaiterType">
            <summary>
            Awaiter type. Will not be null (but can be UnknownType).
            </summary>
        </member>
        <member name="F:ICSharpCode.NRefactory.CSharp.Resolver.AwaitResolveResult.IsCompletedProperty">
            <summary>
            Property representing the IsCompleted property on the awaiter type. Can be null if the awaiter type or the property was not found, or when awaiting a dynamic expression.
            </summary>
        </member>
        <member name="F:ICSharpCode.NRefactory.CSharp.Resolver.AwaitResolveResult.OnCompletedMethod">
            <summary>
            Method representing the OnCompleted method on the awaiter type. Can be null if the awaiter type or the method was not found, or when awaiting a dynamic expression.
            This can also refer to an UnsafeOnCompleted method, if the awaiter type implements <c>System.Runtime.CompilerServices.ICriticalNotifyCompletion</c>.
            </summary>
        </member>
        <member name="F:ICSharpCode.NRefactory.CSharp.Resolver.AwaitResolveResult.GetResultMethod">
            <summary>
            Method representing the GetResult method on the awaiter type. Can be null if the awaiter type or the method was not found, or when awaiting a dynamic expression.
            </summary>
        </member>
        <member name="F:ICSharpCode.NRefactory.CSharp.Resolver.DynamicInvocationType.Invocation">
            <summary>
            The invocation is a normal invocation ( 'a(b)' ).
            </summary>
        </member>
        <member name="F:ICSharpCode.NRefactory.CSharp.Resolver.DynamicInvocationType.Indexing">
            <summary>
            The invocation is an indexing ( 'a[b]' ).
            </summary>
        </member>
        <member name="F:ICSharpCode.NRefactory.CSharp.Resolver.DynamicInvocationType.ObjectCreation">
            <summary>
            The invocation is an object creation ( 'new a(b)' ). Also used when invoking a base constructor ( ' : base(a) ' ) and chaining constructors ( ' : this(a) ').
            </summary>
        </member>
        <member name="T:ICSharpCode.NRefactory.CSharp.Resolver.DynamicInvocationResolveResult">
            <summary>
            Represents the result of an invocation of a member of a dynamic object.
            </summary>
        </member>
        <member name="F:ICSharpCode.NRefactory.CSharp.Resolver.DynamicInvocationResolveResult.Target">
            <summary>
            Target of the invocation. Can be a dynamic expression or a <see cref="T:ICSharpCode.NRefactory.CSharp.Resolver.MethodGroupResolveResult"/>.
            </summary>
        </member>
        <member name="F:ICSharpCode.NRefactory.CSharp.Resolver.DynamicInvocationResolveResult.InvocationType">
            <summary>
            Type of the invocation.
            </summary>
        </member>
        <member name="F:ICSharpCode.NRefactory.CSharp.Resolver.DynamicInvocationResolveResult.Arguments">
            <summary>
            Arguments for the call. Named arguments will be instances of <see cref="T:ICSharpCode.NRefactory.Semantics.NamedArgumentResolveResult"/>.
            </summary>
        </member>
        <member name="F:ICSharpCode.NRefactory.CSharp.Resolver.DynamicInvocationResolveResult.InitializerStatements">
            <summary>
            Gets the list of initializer statements that are appplied to the result of this invocation.
            This is used to represent object and collection initializers.
            With the initializer statements, the <see cref="T:ICSharpCode.NRefactory.Semantics.InitializedObjectResolveResult"/> is used
            to refer to the result of this invocation.
            Initializer statements can only exist if the <see cref="F:ICSharpCode.NRefactory.CSharp.Resolver.DynamicInvocationResolveResult.InvocationType"/> is <see cref="F:ICSharpCode.NRefactory.CSharp.Resolver.DynamicInvocationType.ObjectCreation"/>.
            </summary>
        </member>
        <member name="T:ICSharpCode.NRefactory.CSharp.Resolver.DynamicMemberResolveResult">
            <summary>
            Represents the result of an access to a member of a dynamic object.
            </summary>
        </member>
        <member name="F:ICSharpCode.NRefactory.CSharp.Resolver.DynamicMemberResolveResult.Target">
            <summary>
            Target of the member access (a dynamic object).
            </summary>
        </member>
        <member name="F:ICSharpCode.NRefactory.CSharp.Resolver.DynamicMemberResolveResult.Member">
            <summary>
            Name of the accessed member.
            </summary>
        </member>
        <member name="T:ICSharpCode.NRefactory.CSharp.Resolver.CSharpConversions">
            <summary>
            Contains logic that determines whether an implicit conversion exists between two types.
            </summary>
            <remarks>
            This class is thread-safe.
            </remarks>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.Resolver.CSharpConversions.Get(ICSharpCode.NRefactory.TypeSystem.ICompilation)">
            <summary>
            Gets the Conversions instance for the specified <see cref="T:ICSharpCode.NRefactory.TypeSystem.ICompilation"/>.
            This will make use of the context's cache manager to reuse the Conversions instance.
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.Resolver.CSharpConversions.IsConstraintConvertible(ICSharpCode.NRefactory.TypeSystem.IType,ICSharpCode.NRefactory.TypeSystem.IType)">
            <summary>
            Gets whether the type 'fromType' is convertible to 'toType'
            using one of the conversions allowed when satisying constraints (§4.4.4)
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.Resolver.CSharpConversions.IdentityConversion(ICSharpCode.NRefactory.TypeSystem.IType,ICSharpCode.NRefactory.TypeSystem.IType)">
            <summary>
            Gets whether there is an identity conversion from <paramref name="fromType"/> to <paramref name="toType"/>
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.Resolver.CSharpConversions.UnpackGenericArrayInterface(ICSharpCode.NRefactory.TypeSystem.IType)">
            <summary>
            For IList{T}, ICollection{T}, IEnumerable{T} and IReadOnlyList{T}, returns T.
            Otherwise, returns null.
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.Resolver.CSharpConversions.ImplicitTypeParameterConversion(ICSharpCode.NRefactory.TypeSystem.IType,ICSharpCode.NRefactory.TypeSystem.IType)">
            <summary>
            Implicit conversions involving type parameters.
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.Resolver.CSharpConversions.IsEncompassedBy(ICSharpCode.NRefactory.TypeSystem.IType,ICSharpCode.NRefactory.TypeSystem.IType)">
            <summary>
            Gets whether type A is encompassed by type B.
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.Resolver.CSharpConversions.IsDelegateCompatible(ICSharpCode.NRefactory.TypeSystem.IMethod,ICSharpCode.NRefactory.TypeSystem.IMethod,System.Boolean)">
            <summary>
            Gets whether a method <paramref name="m"/> is compatible with a delegate type.
            §15.2 Delegate compatibility
            </summary>
            <param name="m">The method to test for compatibility</param>
            <param name="invoke">The invoke method of the delegate</param>
            <param name="isExtensionMethodInvocation">Gets whether m is accessed using extension method syntax.
            If this parameter is true, the first parameter of <paramref name="m"/> will be ignored.</param>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.Resolver.CSharpConversions.BetterConversion(ICSharpCode.NRefactory.Semantics.ResolveResult,ICSharpCode.NRefactory.TypeSystem.IType,ICSharpCode.NRefactory.TypeSystem.IType)">
            <summary>
            Gets the better conversion (C# 4.0 spec, §7.5.3.3)
            </summary>
            <returns>0 = neither is better; 1 = t1 is better; 2 = t2 is better</returns>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.Resolver.CSharpConversions.UnpackTask(ICSharpCode.NRefactory.TypeSystem.IType)">
            <summary>
            Unpacks the generic Task[T]. Returns null if the input is not Task[T].
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.Resolver.CSharpConversions.BetterConversion(ICSharpCode.NRefactory.TypeSystem.IType,ICSharpCode.NRefactory.TypeSystem.IType,ICSharpCode.NRefactory.TypeSystem.IType)">
            <summary>
            Gets the better conversion (C# 4.0 spec, §7.5.3.4)
            </summary>
            <returns>0 = neither is better; 1 = t1 is better; 2 = t2 is better</returns>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.Resolver.CSharpConversions.BetterConversionTarget(ICSharpCode.NRefactory.TypeSystem.IType,ICSharpCode.NRefactory.TypeSystem.IType)">
            <summary>
            Gets the better conversion target (C# 4.0 spec, §7.5.3.5)
            </summary>
            <returns>0 = neither is better; 1 = t1 is better; 2 = t2 is better</returns>
        </member>
        <member name="T:ICSharpCode.NRefactory.CSharp.Resolver.CSharpAstResolver">
            <summary>
            Resolves C# AST nodes.
            </summary>
            <remarks>This class is thread-safe.</remarks>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.Resolver.CSharpAstResolver.#ctor(ICSharpCode.NRefactory.TypeSystem.ICompilation,ICSharpCode.NRefactory.CSharp.SyntaxTree,ICSharpCode.NRefactory.CSharp.TypeSystem.CSharpUnresolvedFile)">
            <summary>
            Creates a new C# AST resolver.
            Use this overload if you are resolving within a complete C# file.
            </summary>
            <param name="compilation">The current compilation.</param>
            <param name="syntaxTree">The syntax tree to be resolved.</param>
            <param name="unresolvedFile">
            Optional: Result of <see cref="M:ICSharpCode.NRefactory.CSharp.SyntaxTree.ToTypeSystem"/> for the file being resolved.
            <para>
            This is used for setting up the context on the resolver. The unresolved file must be registered in the compilation.
            </para>
            <para>
            When a unresolvedFile is specified, the resolver will use the member's StartLocation/EndLocation to identify
            member declarations in the AST with members in the type system.
            When no unresolvedFile is specified (<c>null</c> value for this parameter), the resolver will instead compare the
            member's signature in the AST with the signature in the type system.
            </para>
            </param>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.Resolver.CSharpAstResolver.#ctor(ICSharpCode.NRefactory.CSharp.Resolver.CSharpResolver,ICSharpCode.NRefactory.CSharp.AstNode,ICSharpCode.NRefactory.CSharp.TypeSystem.CSharpUnresolvedFile)">
            <summary>
            Creates a new C# AST resolver.
            Use this overload if you are resolving code snippets (not necessarily complete files).
            </summary>
            <param name="resolver">The resolver state at the root node (to be more precise: just outside the root node).</param>
            <param name="rootNode">The root node of the tree to be resolved.</param>
            <param name="unresolvedFile">
            Optional: Result of <see cref="M:ICSharpCode.NRefactory.CSharp.SyntaxTree.ToTypeSystem"/> for the file being resolved.
            <para>
            This is used for setting up the context on the resolver. The unresolved file must be registered in the compilation.
            </para>
            <para>
            When a unresolvedFile is specified, the resolver will use the member's StartLocation/EndLocation to identify
            member declarations in the AST with members in the type system.
            When no unresolvedFile is specified (<c>null</c> value for this parameter), the resolver will instead compare the
            member's signature in the AST with the signature in the type system.
            </para>
            </param>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.Resolver.CSharpAstResolver.ApplyNavigator(ICSharpCode.NRefactory.CSharp.Resolver.IResolveVisitorNavigator,System.Threading.CancellationToken)">
            <summary>
            Applies a resolver navigator. This will resolve the nodes requested by the navigator, and will inform the
            navigator of the results.
            This method must be called as the first operation on the CSharpAstResolver, it is invalid to apply a navigator
            after a portion of the file was already resolved.
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.Resolver.CSharpAstResolver.Resolve(ICSharpCode.NRefactory.CSharp.AstNode,System.Threading.CancellationToken)">
            <summary>
            Resolves the specified node.
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.Resolver.CSharpAstResolver.GetResolverStateBefore(ICSharpCode.NRefactory.CSharp.AstNode,System.Threading.CancellationToken)">
            <summary>
            Gets the resolver state immediately before the specified node.
            That is, if the node is a variable declaration, the returned state will not contain the newly declared variable.
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.Resolver.CSharpAstResolver.GetResolverStateAfter(ICSharpCode.NRefactory.CSharp.AstNode,System.Threading.CancellationToken)">
            <summary>
            Gets the resolver state immediately after the specified node.
            That is, if the node is a variable declaration, the returned state will include the newly declared variable.
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.Resolver.CSharpAstResolver.GetExpectedType(ICSharpCode.NRefactory.CSharp.Expression,System.Threading.CancellationToken)">
            <summary>
            Gets the expected type for the specified node. This is the type being that a node is being converted to.
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.Resolver.CSharpAstResolver.GetConversion(ICSharpCode.NRefactory.CSharp.Expression,System.Threading.CancellationToken)">
            <summary>
            Gets the conversion that is being applied to the specified expression.
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.Resolver.CSharpAstResolver.IsUnresolvableNode(ICSharpCode.NRefactory.CSharp.AstNode)">
            <summary>
            Gets whether the specified node is unresolvable.
            </summary>
        </member>
        <member name="P:ICSharpCode.NRefactory.CSharp.Resolver.CSharpAstResolver.TypeResolveContext">
            <summary>
            Gets the type resolve context for the root resolver.
            </summary>
        </member>
        <member name="P:ICSharpCode.NRefactory.CSharp.Resolver.CSharpAstResolver.Compilation">
            <summary>
            Gets the compilation for this resolver.
            </summary>
        </member>
        <member name="P:ICSharpCode.NRefactory.CSharp.Resolver.CSharpAstResolver.RootNode">
            <summary>
            Gets the root node for which this CSharpAstResolver was created.
            </summary>
        </member>
        <member name="P:ICSharpCode.NRefactory.CSharp.Resolver.CSharpAstResolver.UnresolvedFile">
            <summary>
            Gets the unresolved file used by this CSharpAstResolver.
            Can return null.
            </summary>
        </member>
        <member name="T:ICSharpCode.NRefactory.CSharp.Resolver.CSharpInvocationResolveResult">
            <summary>
            Represents the result of a method, constructor or indexer invocation.
            Provides additional C#-specific information for InvocationResolveResult.
            </summary>
        </member>
        <member name="F:ICSharpCode.NRefactory.CSharp.Resolver.CSharpInvocationResolveResult.IsExtensionMethodInvocation">
            <summary>
            Gets whether this invocation is calling an extension method using extension method syntax.
            </summary>
        </member>
        <member name="F:ICSharpCode.NRefactory.CSharp.Resolver.CSharpInvocationResolveResult.IsDelegateInvocation">
            <summary>
            Gets whether this invocation is calling a delegate (without explicitly calling ".Invoke()").
            </summary>
        </member>
        <member name="F:ICSharpCode.NRefactory.CSharp.Resolver.CSharpInvocationResolveResult.IsExpandedForm">
            <summary>
            Gets whether a params-Array is being used in its expanded form.
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.Resolver.CSharpInvocationResolveResult.GetArgumentToParameterMap">
            <summary>
            Gets an array that maps argument indices to parameter indices.
            For arguments that could not be mapped to any parameter, the value will be -1.
            
            parameterIndex = ArgumentToParameterMap[argumentIndex]
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.Resolver.CSharpOperators.Get(ICSharpCode.NRefactory.TypeSystem.ICompilation)">
            <summary>
            Gets the CSharpOperators instance for the specified <see cref="T:ICSharpCode.NRefactory.TypeSystem.ICompilation"/>.
            This will make use of the context's cache manager (if available) to reuse the CSharpOperators instance.
            </summary>
        </member>
        <member name="T:ICSharpCode.NRefactory.CSharp.Resolver.OverloadResolution.ILiftedOperator">
            <summary>
            Implement this interface to give overload resolution a hint that the member represents a lifted operator,
            which is used in the tie-breaking rules.
            </summary>
        </member>
        <member name="T:ICSharpCode.NRefactory.CSharp.Resolver.OverloadResolution">
            <summary>
            C# overload resolution (C# 4.0 spec: §7.5).
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.Resolver.OverloadResolution.AddCandidate(ICSharpCode.NRefactory.TypeSystem.IParameterizedMember)">
            <summary>
            Adds a candidate to overload resolution.
            </summary>
            <param name="member">The candidate member to add.</param>
            <returns>The errors that prevent the member from being applicable, if any.
            Note: this method does not return errors that do not affect applicability.</returns>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.Resolver.OverloadResolution.AddCandidate(ICSharpCode.NRefactory.TypeSystem.IParameterizedMember,ICSharpCode.NRefactory.CSharp.Resolver.OverloadResolutionErrors)">
            <summary>
            Adds a candidate to overload resolution.
            </summary>
            <param name="member">The candidate member to add.</param>
            <param name="additionalErrors">Additional errors that apply to the candidate.
            This is used to represent errors during member lookup (e.g. OverloadResolutionErrors.Inaccessible)
            in overload resolution.</param>
            <returns>The errors that prevent the member from being applicable, if any.
            Note: this method does not return errors that do not affect applicability.</returns>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.Resolver.OverloadResolution.CalculateCandidate(ICSharpCode.NRefactory.CSharp.Resolver.OverloadResolution.Candidate)">
            <summary>
            Calculates applicability etc. for the candidate.
            </summary>
            <returns>True if the calculation was successful, false if the candidate should be removed without reporting an error</returns>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.Resolver.OverloadResolution.AddMethodLists(System.Collections.Generic.IList{ICSharpCode.NRefactory.CSharp.Resolver.MethodListWithDeclaringType})">
            <summary>
            Adds all candidates from the method lists.
            
            This method implements the logic that causes applicable methods in derived types to hide
            all methods in base types.
            </summary>
            <param name="methodLists">The methods, grouped by declaring type. Base types must come first in the list.</param>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.Resolver.OverloadResolution.ValidateConstraints(ICSharpCode.NRefactory.TypeSystem.ITypeParameter,ICSharpCode.NRefactory.TypeSystem.IType,ICSharpCode.NRefactory.TypeSystem.TypeVisitor)">
            <summary>
            Validates whether the given type argument satisfies the constraints for the given type parameter.
            </summary>
            <param name="typeParameter">The type parameter.</param>
            <param name="typeArgument">The type argument.</param>
            <param name="substitution">The substitution that defines how type parameters are replaced with type arguments.
            The substitution is used to check constraints that depend on other type parameters (or recursively on the same type parameter).
            May be null if no substitution should be used.</param>
            <returns>True if the constraints are satisfied; false otherwise.</returns>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.Resolver.OverloadResolution.IsApplicable(ICSharpCode.NRefactory.CSharp.Resolver.OverloadResolutionErrors)">
            <summary>
            Returns whether a candidate with the given errors is still considered to be applicable.
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.Resolver.OverloadResolution.BetterFunctionMember(ICSharpCode.NRefactory.CSharp.Resolver.OverloadResolution.Candidate,ICSharpCode.NRefactory.CSharp.Resolver.OverloadResolution.Candidate)">
            <summary>
            Returns 1 if c1 is better than c2; 2 if c2 is better than c1; or 0 if neither is better.
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.Resolver.OverloadResolution.GetArgumentToParameterMap">
            <summary>
            Gets an array that maps argument indices to parameter indices.
            For arguments that could not be mapped to any parameter, the value will be -1.
            
            parameterIndex = GetArgumentToParameterMap()[argumentIndex]
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.Resolver.OverloadResolution.GetArgumentsWithConversions">
            <summary>
            Returns the arguments for the method call in the order they were provided (not in the order of the parameters).
            Arguments are wrapped in a <see cref="T:ICSharpCode.NRefactory.Semantics.ConversionResolveResult"/> if an implicit conversion is being applied
            to them when calling the method.
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.Resolver.OverloadResolution.GetArgumentsWithConversionsAndNames">
            <summary>
            Returns the arguments for the method call in the order they were provided (not in the order of the parameters).
            Arguments are wrapped in a <see cref="T:ICSharpCode.NRefactory.Semantics.ConversionResolveResult"/> if an implicit conversion is being applied
            to them when calling the method.
            For arguments where an explicit argument name was provided, the argument will
            be wrapped in a <see cref="T:ICSharpCode.NRefactory.Semantics.NamedArgumentResolveResult"/>.
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.Resolver.OverloadResolution.CreateResolveResult(ICSharpCode.NRefactory.Semantics.ResolveResult,System.Collections.Generic.IList{ICSharpCode.NRefactory.Semantics.ResolveResult})">
            <summary>
            Creates a ResolveResult representing the result of overload resolution.
            </summary>
            <param name="targetResolveResult">
            The target expression of the call. May be <c>null</c> for static methods/constructors.
            </param>
            <param name="initializerStatements">
            Statements for Objects/Collections initializer.
            <see cref="F:ICSharpCode.NRefactory.Semantics.InvocationResolveResult.InitializerStatements"/>
            </param>
        </member>
        <member name="P:ICSharpCode.NRefactory.CSharp.Resolver.OverloadResolution.IsExtensionMethodInvocation">
            <summary>
            Gets/Sets whether the methods are extension methods that are being called using extension method syntax.
            </summary>
            <remarks>
            Setting this property to true restricts the possible conversions on the first argument to
            implicit identity, reference, or boxing conversions.
            </remarks>
        </member>
        <member name="P:ICSharpCode.NRefactory.CSharp.Resolver.OverloadResolution.AllowExpandingParams">
            <summary>
            Gets/Sets whether expanding 'params' into individual elements is allowed.
            The default value is true.
            </summary>
        </member>
        <member name="P:ICSharpCode.NRefactory.CSharp.Resolver.OverloadResolution.AllowOptionalParameters">
            <summary>
            Gets/Sets whether optional parameters may be left at their default value.
            The default value is true.
            If this property is set to false, optional parameters will be treated like regular parameters.
            </summary>
        </member>
        <member name="P:ICSharpCode.NRefactory.CSharp.Resolver.OverloadResolution.CheckForOverflow">
            <summary>
            Gets/Sets whether ConversionResolveResults created by this OverloadResolution
            instance apply overflow checking.
            The default value is false.
            </summary>
        </member>
        <member name="P:ICSharpCode.NRefactory.CSharp.Resolver.OverloadResolution.Arguments">
            <summary>
            Gets the arguments for which this OverloadResolution instance was created.
            </summary>
        </member>
        <member name="P:ICSharpCode.NRefactory.CSharp.Resolver.OverloadResolution.BestCandidateErrors">
            <summary>
            Returns the errors that apply to the best candidate.
            This includes additional errors that do not affect applicability (e.g. AmbiguousMatch, MethodConstraintsNotSatisfied)
            </summary>
        </member>
        <member name="P:ICSharpCode.NRefactory.CSharp.Resolver.OverloadResolution.ArgumentConversions">
            <summary>
            Gets the implicit conversions that are being applied to the arguments.
            </summary>
        </member>
        <member name="F:ICSharpCode.NRefactory.CSharp.Resolver.OverloadResolution.Candidate.IsExpandedForm">
            <summary>
            Returns the normal form candidate, if this is an expanded candidate.
            </summary>
        </member>
        <member name="F:ICSharpCode.NRefactory.CSharp.Resolver.OverloadResolution.Candidate.ParameterTypes">
            <summary>
            Gets the parameter types. In the first step, these are the types without any substition.
            After type inference, substitutions will be performed.
            </summary>
        </member>
        <member name="F:ICSharpCode.NRefactory.CSharp.Resolver.OverloadResolution.Candidate.ArgumentToParameterMap">
            <summary>
            argument index -> parameter index; -1 for arguments that could not be mapped
            </summary>
        </member>
        <member name="F:ICSharpCode.NRefactory.CSharp.Resolver.OverloadResolution.Candidate.Parameters">
            <summary>
            Gets the original member parameters (before any substitution!)
            </summary>
        </member>
        <member name="F:ICSharpCode.NRefactory.CSharp.Resolver.OverloadResolution.Candidate.TypeParameters">
            <summary>
            Gets the original method type parameters (before any substitution!)
            </summary>
        </member>
        <member name="F:ICSharpCode.NRefactory.CSharp.Resolver.OverloadResolution.Candidate.ArgumentConversions">
            <summary>
            Conversions applied to the arguments.
            This field is set by the CheckApplicability step.
            </summary>
        </member>
        <member name="T:ICSharpCode.NRefactory.CSharp.Resolver.OverloadResolution.ILiftedOperator">
            <summary>
            Implement this interface to give overload resolution a hint that the member represents a lifted operator,
            which is used in the tie-breaking rules.
            </summary>
        </member>
        <member name="T:ICSharpCode.NRefactory.CSharp.Resolver.CSharpResolver">
            <summary>
            Contains the main resolver logic.
            </summary>
            <remarks>
            This class is thread-safe.
            </remarks>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.Resolver.CSharpResolver.WithCheckForOverflow(System.Boolean)">
            <summary>
            Sets whether the current context is <c>checked</c>.
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.Resolver.CSharpResolver.WithIsWithinLambdaExpression(System.Boolean)">
            <summary>
            Sets whether the resolver is currently within a lambda expression.
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.Resolver.CSharpResolver.WithCurrentMember(ICSharpCode.NRefactory.TypeSystem.IMember)">
            <summary>
            Sets the current member definition.
            </summary>
            <remarks>Don't forget to also set CurrentTypeDefinition when setting CurrentMember;
            setting one of the properties does not automatically set the other.</remarks>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.Resolver.CSharpResolver.WithCurrentUsingScope(ICSharpCode.NRefactory.CSharp.TypeSystem.ResolvedUsingScope)">
            <summary>
            Sets the current using scope that is used to look up identifiers as class names.
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.Resolver.CSharpResolver.WithCurrentTypeDefinition(ICSharpCode.NRefactory.TypeSystem.ITypeDefinition)">
            <summary>
            Sets the current type definition.
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.Resolver.CSharpResolver.PushBlock">
            <summary>
            Opens a new scope for local variables.
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.Resolver.CSharpResolver.PopBlock">
            <summary>
            Closes the current scope for local variables; removing all variables in that scope.
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.Resolver.CSharpResolver.AddVariable(ICSharpCode.NRefactory.TypeSystem.IVariable)">
            <summary>
            Adds a new variable or lambda parameter to the current block.
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.Resolver.CSharpResolver.PopLastVariable">
            <summary>
            Removes the variable that was just added.
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.Resolver.CSharpResolver.PushObjectInitializer(ICSharpCode.NRefactory.Semantics.ResolveResult)">
            <summary>
            Pushes the type of the object that is currently being initialized.
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.Resolver.CSharpResolver.Clone">
            <summary>
            Creates a copy of this CSharp resolver.
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.Resolver.CSharpResolver.HandleEnumComparison(ICSharpCode.NRefactory.CSharp.BinaryOperatorType,ICSharpCode.NRefactory.TypeSystem.IType,System.Boolean,ICSharpCode.NRefactory.Semantics.ResolveResult,ICSharpCode.NRefactory.Semantics.ResolveResult)">
            <summary>
            Handle the case where an enum value is compared with another enum value
            bool operator op(E x, E y);
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.Resolver.CSharpResolver.HandleEnumSubtraction(System.Boolean,ICSharpCode.NRefactory.TypeSystem.IType,ICSharpCode.NRefactory.Semantics.ResolveResult,ICSharpCode.NRefactory.Semantics.ResolveResult)">
            <summary>
            Handle the case where an enum value is subtracted from another enum value
            U operator –(E x, E y);
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.Resolver.CSharpResolver.HandleEnumOperator(System.Boolean,ICSharpCode.NRefactory.TypeSystem.IType,ICSharpCode.NRefactory.CSharp.BinaryOperatorType,ICSharpCode.NRefactory.Semantics.ResolveResult,ICSharpCode.NRefactory.Semantics.ResolveResult)">
            <summary>
            Handle the following enum operators:
            E operator +(E x, U y);
            E operator +(U x, E y);
            E operator –(E x, U y);
            E operator &amp;(E x, E y);
            E operator |(E x, E y);
            E operator ^(E x, E y);
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.Resolver.CSharpResolver.ResolveAlias(System.String)">
            <summary>
            Looks up an alias (identifier in front of :: operator)
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.Resolver.CSharpResolver.CreateMemberLookup">
            <summary>
            Creates a MemberLookup instance using this resolver's settings.
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.Resolver.CSharpResolver.CreateMemberLookup(ICSharpCode.NRefactory.CSharp.NameLookupMode)">
            <summary>
            Creates a MemberLookup instance using this resolver's settings.
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.Resolver.CSharpResolver.GetExtensionMethods(System.String,System.Collections.Generic.IList{ICSharpCode.NRefactory.TypeSystem.IType})">
            <summary>
            Gets all extension methods that are available in the current context.
            </summary>
            <param name="name">Name of the extension method. Pass null to retrieve all extension methods.</param>
            <param name="typeArguments">Explicitly provided type arguments.
            An empty list will return all matching extension method definitions;
            a non-empty list will return <see cref="T:ICSharpCode.NRefactory.TypeSystem.Implementation.SpecializedMethod"/>s for all extension methods
            with the matching number of type parameters.</param>
            <remarks>
            The results are stored in nested lists because they are grouped by using scope.
            That is, for "using SomeExtensions; namespace X { using MoreExtensions; ... }",
            the return value will be
            new List {
               new List { all extensions from MoreExtensions },
               new List { all extensions from SomeExtensions }
            }
            </remarks>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.Resolver.CSharpResolver.GetExtensionMethods(ICSharpCode.NRefactory.TypeSystem.IType,System.String,System.Collections.Generic.IList{ICSharpCode.NRefactory.TypeSystem.IType},System.Boolean)">
            <summary>
            Gets the extension methods that are called 'name'
            and are applicable with a first argument type of 'targetType'.
            </summary>
            <param name="targetType">Type of the 'this' argument</param>
            <param name="name">Name of the extension method. Pass null to retrieve all extension methods.</param>
            <param name="typeArguments">Explicitly provided type arguments.
            An empty list will return all matching extension method definitions;
            a non-empty list will return <see cref="T:ICSharpCode.NRefactory.TypeSystem.Implementation.SpecializedMethod"/>s for all extension methods
            with the matching number of type parameters.</param>
            <param name="substituteInferredTypes">
            Specifies whether to produce a <see cref="T:ICSharpCode.NRefactory.TypeSystem.Implementation.SpecializedMethod"/>
            when type arguments could be inferred from <paramref name="targetType"/>. This parameter
            is only used for inferred types and has no effect if <paramref name="typeArguments"/> is non-empty.
            </param>
            <remarks>
            The results are stored in nested lists because they are grouped by using scope.
            That is, for "using SomeExtensions; namespace X { using MoreExtensions; ... }",
            the return value will be
            new List {
               new List { all extensions from MoreExtensions },
               new List { all extensions from SomeExtensions }
            }
            </remarks>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.Resolver.CSharpResolver.IsEligibleExtensionMethod(ICSharpCode.NRefactory.TypeSystem.IType,ICSharpCode.NRefactory.TypeSystem.IMethod,System.Boolean,ICSharpCode.NRefactory.TypeSystem.IType[]@)">
            <summary>
            Checks whether the specified extension method is eligible on the target type.
            </summary>
            <param name="targetType">Target type that is passed as first argument to the extension method.</param>
            <param name="method">The extension method.</param>
            <param name="useTypeInference">Whether to perform type inference for the method.
            Use <c>false</c> if <paramref name="method"/> is already specialized (e.g. when type arguments were given explicitly).
            Otherwise, use <c>true</c>.
            </param>
            <param name="outInferredTypes">If the method is generic and <paramref name="useTypeInference"/> is <c>true</c>,
            and at least some of the type arguments could be inferred, this parameter receives the inferred type arguments.
            Since only the type for the first parameter is considered, not all type arguments may be inferred.
            If an array is returned, any slot with an uninferred type argument will be set to the method's
            corresponding type parameter.
            </param>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.Resolver.CSharpResolver.GetAllExtensionMethods">
            <summary>
            Gets all extension methods available in the current using scope.
            This list includes unaccessible
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.Resolver.CSharpResolver.ResolveInvocation(ICSharpCode.NRefactory.Semantics.ResolveResult,ICSharpCode.NRefactory.Semantics.ResolveResult[],System.String[])">
            <summary>
            Resolves an invocation.
            </summary>
            <param name="target">The target of the invocation. Usually a MethodGroupResolveResult.</param>
            <param name="arguments">
            Arguments passed to the method.
            The resolver may mutate this array to wrap elements in <see cref="T:ICSharpCode.NRefactory.Semantics.ConversionResolveResult"/>s!
            </param>
            <param name="argumentNames">
            The argument names. Pass the null string for positional arguments.
            </param>
            <returns>InvocationResolveResult or UnknownMethodResolveResult</returns>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.Resolver.CSharpResolver.ResolveIndexer(ICSharpCode.NRefactory.Semantics.ResolveResult,ICSharpCode.NRefactory.Semantics.ResolveResult[],System.String[])">
            <summary>
            Resolves an indexer access.
            </summary>
            <param name="target">Target expression.</param>
            <param name="arguments">
            Arguments passed to the indexer.
            The resolver may mutate this array to wrap elements in <see cref="T:ICSharpCode.NRefactory.Semantics.ConversionResolveResult"/>s!
            </param>
            <param name="argumentNames">
            The argument names. Pass the null string for positional arguments.
            </param>
            <returns>ArrayAccessResolveResult, InvocationResolveResult, or ErrorResolveResult</returns>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.Resolver.CSharpResolver.AdjustArrayAccessArguments(ICSharpCode.NRefactory.Semantics.ResolveResult[])">
            <summary>
            Converts all arguments to int,uint,long or ulong.
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.Resolver.CSharpResolver.ResolveObjectCreation(ICSharpCode.NRefactory.TypeSystem.IType,ICSharpCode.NRefactory.Semantics.ResolveResult[],System.String[],System.Boolean,System.Collections.Generic.IList{ICSharpCode.NRefactory.Semantics.ResolveResult})">
            <summary>
            Resolves an object creation.
            </summary>
            <param name="type">Type of the object to create.</param>
            <param name="arguments">
            Arguments passed to the constructor.
            The resolver may mutate this array to wrap elements in <see cref="T:ICSharpCode.NRefactory.Semantics.ConversionResolveResult"/>s!
            </param>
            <param name="argumentNames">
            The argument names. Pass the null string for positional arguments.
            </param>
            <param name="allowProtectedAccess">
            Whether to allow calling protected constructors.
            This should be false except when resolving constructor initializers.
            </param>
            <param name="initializerStatements">
            Statements for Objects/Collections initializer.
            <see cref="F:ICSharpCode.NRefactory.Semantics.InvocationResolveResult.InitializerStatements"/>
            </param>
            <returns>InvocationResolveResult or ErrorResolveResult</returns>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.Resolver.CSharpResolver.ResolveSizeOf(ICSharpCode.NRefactory.TypeSystem.IType)">
            <summary>
            Resolves 'sizeof(type)'.
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.Resolver.CSharpResolver.ResolveThisReference">
            <summary>
            Resolves 'this'.
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.Resolver.CSharpResolver.ResolveBaseReference">
            <summary>
            Resolves 'base'.
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.Resolver.CSharpResolver.ResolveCondition(ICSharpCode.NRefactory.Semantics.ResolveResult)">
            <summary>
            Converts the input to <c>bool</c> using the rules for boolean expressions.
            That is, <c>operator true</c> is used if a regular conversion to <c>bool</c> is not possible.
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.Resolver.CSharpResolver.ResolveConditionFalse(ICSharpCode.NRefactory.Semantics.ResolveResult)">
            <summary>
            Converts the negated input to <c>bool</c> using the rules for boolean expressions.
            Computes <c>!(bool)input</c> if the implicit cast to bool is valid; otherwise
            computes <c>input.operator false()</c>.
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.Resolver.CSharpResolver.ResolveArrayCreation(ICSharpCode.NRefactory.TypeSystem.IType,System.Int32[],ICSharpCode.NRefactory.Semantics.ResolveResult[])">
            <summary>
            Resolves an array creation.
            </summary>
            <param name="elementType">
            The array element type.
            Pass null to resolve an implicitly-typed array creation.
            </param>
            <param name="sizeArguments">
            The size arguments.
            The length of this array will be used as the number of dimensions of the array type.
            Negative values will be treated as errors.
            </param>
            <param name="initializerElements">
            The initializer elements. May be null if no array initializer was specified.
            The resolver may mutate this array to wrap elements in <see cref="T:ICSharpCode.NRefactory.Semantics.ConversionResolveResult"/>s!
            </param>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.Resolver.CSharpResolver.ResolveArrayCreation(ICSharpCode.NRefactory.TypeSystem.IType,ICSharpCode.NRefactory.Semantics.ResolveResult[],ICSharpCode.NRefactory.Semantics.ResolveResult[])">
            <summary>
            Resolves an array creation.
            </summary>
            <param name="elementType">
            The array element type.
            Pass null to resolve an implicitly-typed array creation.
            </param>
            <param name="sizeArguments">
            The size arguments.
            The length of this array will be used as the number of dimensions of the array type.
            The resolver may mutate this array to wrap elements in <see cref="T:ICSharpCode.NRefactory.Semantics.ConversionResolveResult"/>s!
            </param>
            <param name="initializerElements">
            The initializer elements. May be null if no array initializer was specified.
            The resolver may mutate this array to wrap elements in <see cref="T:ICSharpCode.NRefactory.Semantics.ConversionResolveResult"/>s!
            </param>
        </member>
        <member name="P:ICSharpCode.NRefactory.CSharp.Resolver.CSharpResolver.Compilation">
            <summary>
            Gets the compilation used by the resolver.
            </summary>
        </member>
        <member name="P:ICSharpCode.NRefactory.CSharp.Resolver.CSharpResolver.CurrentTypeResolveContext">
            <summary>
            Gets the current type resolve context.
            </summary>
        </member>
        <member name="P:ICSharpCode.NRefactory.CSharp.Resolver.CSharpResolver.CheckForOverflow">
            <summary>
            Gets whether the current context is <c>checked</c>.
            </summary>
        </member>
        <member name="P:ICSharpCode.NRefactory.CSharp.Resolver.CSharpResolver.IsWithinLambdaExpression">
            <summary>
            Gets whether the resolver is currently within a lambda expression.
            </summary>
        </member>
        <member name="P:ICSharpCode.NRefactory.CSharp.Resolver.CSharpResolver.CurrentMember">
            <summary>
            Gets the current member definition that is used to look up identifiers as parameters
            or type parameters.
            </summary>
        </member>
        <member name="P:ICSharpCode.NRefactory.CSharp.Resolver.CSharpResolver.CurrentUsingScope">
            <summary>
            Gets the current using scope that is used to look up identifiers as class names.
            </summary>
        </member>
        <member name="P:ICSharpCode.NRefactory.CSharp.Resolver.CSharpResolver.CurrentTypeDefinition">
            <summary>
            Gets the current type definition.
            </summary>
        </member>
        <member name="P:ICSharpCode.NRefactory.CSharp.Resolver.CSharpResolver.LocalVariables">
            <summary>
            Gets all currently visible local variables and lambda parameters.
            </summary>
        </member>
        <member name="P:ICSharpCode.NRefactory.CSharp.Resolver.CSharpResolver.IsInObjectInitializer">
            <summary>
            Gets whether this context is within an object initializer.
            </summary>
        </member>
        <member name="P:ICSharpCode.NRefactory.CSharp.Resolver.CSharpResolver.CurrentObjectInitializer">
            <summary>
            Gets the current object initializer. This usually is an <see cref="T:ICSharpCode.NRefactory.Semantics.InitializedObjectResolveResult"/>
            or (for nested initializers) a semantic tree based on an <see cref="T:ICSharpCode.NRefactory.Semantics.InitializedObjectResolveResult"/>.
            Returns ErrorResolveResult if there is no object initializer.
            </summary>
        </member>
        <member name="P:ICSharpCode.NRefactory.CSharp.Resolver.CSharpResolver.CurrentObjectInitializerType">
            <summary>
            Gets the type of the object currently being initialized.
            Returns SharedTypes.Unknown if no object initializer is currently open (or if the object initializer
            has unknown type).
            </summary>
        </member>
        <member name="T:ICSharpCode.NRefactory.CSharp.Resolver.DetectSkippableNodesNavigator">
            <summary>
            When an <see cref="T:ICSharpCode.NRefactory.CSharp.Resolver.IResolveVisitorNavigator"/> is searching for specific nodes
            (e.g. all IdentifierExpressions), it has to scan the whole syntax tree for those nodes.
            However, scanning in the ResolveVisitor is expensive (e.g. any lambda that is scanned must be resolved),
            so it makes sense to detect when a whole subtree is scan-only, and skip that tree instead.
            
            The DetectSkippableNodesNavigator performs this job by running the input IResolveVisitorNavigator
            over the whole AST, and detecting subtrees that are scan-only, and replaces them with Skip.
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.Resolver.DetectSkippableNodesNavigator.Scan(ICSharpCode.NRefactory.CSharp.AstNode)">
            <inheritdoc/>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.Resolver.DetectSkippableNodesNavigator.Resolved(ICSharpCode.NRefactory.CSharp.AstNode,ICSharpCode.NRefactory.Semantics.ResolveResult)">
            <inheritdoc/>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.Resolver.DetectSkippableNodesNavigator.ProcessConversion(ICSharpCode.NRefactory.CSharp.Expression,ICSharpCode.NRefactory.Semantics.ResolveResult,ICSharpCode.NRefactory.Semantics.Conversion,ICSharpCode.NRefactory.TypeSystem.IType)">
            <inheritdoc/>
        </member>
        <member name="T:ICSharpCode.NRefactory.CSharp.Resolver.FindReferencedEntities">
            <summary>
            Find all entities that are referenced in the scanned AST.
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.Resolver.FindReferencedEntities.#ctor(System.Action{ICSharpCode.NRefactory.CSharp.AstNode,ICSharpCode.NRefactory.TypeSystem.IEntity})">
            <summary>
            Creates a new FindReferencedEntities instance that
            looks for entity definitions.
            The visitor will report type definitions and member definitions (not specialized members).
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.Resolver.FindReferencedEntities.#ctor(System.Action{ICSharpCode.NRefactory.CSharp.AstNode,ICSharpCode.NRefactory.TypeSystem.IType},System.Action{ICSharpCode.NRefactory.CSharp.AstNode,ICSharpCode.NRefactory.TypeSystem.IMember})">
            <summary>
            Creates a new FindReferencedEntities instance that
            looks for types and members.
            The visitor will report parameterized types and potentially specialized members.
            </summary>
        </member>
        <member name="T:ICSharpCode.NRefactory.CSharp.Resolver.FindReferences">
            <summary>
            'Find references' implementation.
            </summary>
            <remarks>
            This class is thread-safe.
            The intended multi-threaded usage is to call GetSearchScopes() once, and then
            call FindReferencesInFile() concurrently on multiple threads (parallel foreach over all interesting files).
            </remarks>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.Resolver.FindReferences.GetEffectiveAccessibility(ICSharpCode.NRefactory.TypeSystem.IEntity)">
            <summary>
            Gets the effective accessibility of the specified entity -
            that is, the accessibility viewed from the top level.
            </summary>
            <remarks>
            internal member in public class -> internal
            public member in internal class -> internal
            protected member in public class -> protected
            protected member in internal class -> protected and internal
            </remarks>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.Resolver.FindReferences.GetInterestingFiles(ICSharpCode.NRefactory.CSharp.Resolver.IFindReferenceSearchScope,ICSharpCode.NRefactory.TypeSystem.ICompilation)">
            <summary>
            Gets the file names that possibly contain references to the element being searched for.
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.Resolver.FindReferences.FindReferencesInFile(ICSharpCode.NRefactory.CSharp.Resolver.IFindReferenceSearchScope,ICSharpCode.NRefactory.CSharp.TypeSystem.CSharpUnresolvedFile,ICSharpCode.NRefactory.CSharp.SyntaxTree,ICSharpCode.NRefactory.TypeSystem.ICompilation,ICSharpCode.NRefactory.CSharp.Resolver.FoundReferenceCallback,System.Threading.CancellationToken)">
            <summary>
            Finds all references in the given file.
            </summary>
            <param name="searchScope">The search scope for which to look.</param>
            <param name="unresolvedFile">The type system representation of the file being searched.</param>
            <param name="syntaxTree">The syntax tree of the file being searched.</param>
            <param name="compilation">The compilation for the project that contains the file.</param>
            <param name="callback">Callback used to report the references that were found.</param>
            <param name="cancellationToken">CancellationToken that may be used to cancel the operation.</param>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.Resolver.FindReferences.FindReferencesInFile(System.Collections.Generic.IList{ICSharpCode.NRefactory.CSharp.Resolver.IFindReferenceSearchScope},ICSharpCode.NRefactory.CSharp.TypeSystem.CSharpUnresolvedFile,ICSharpCode.NRefactory.CSharp.SyntaxTree,ICSharpCode.NRefactory.TypeSystem.ICompilation,ICSharpCode.NRefactory.CSharp.Resolver.FoundReferenceCallback,System.Threading.CancellationToken)">
            <summary>
            Finds all references in the given file.
            </summary>
            <param name="searchScopes">The search scopes for which to look.</param>
            <param name="unresolvedFile">The type system representation of the file being searched.</param>
            <param name="syntaxTree">The syntax tree of the file being searched.</param>
            <param name="compilation">The compilation for the project that contains the file.</param>
            <param name="callback">Callback used to report the references that were found.</param>
            <param name="cancellationToken">CancellationToken that may be used to cancel the operation.</param>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.Resolver.FindReferences.FindLocalReferences(ICSharpCode.NRefactory.TypeSystem.IVariable,ICSharpCode.NRefactory.CSharp.TypeSystem.CSharpUnresolvedFile,ICSharpCode.NRefactory.CSharp.SyntaxTree,ICSharpCode.NRefactory.TypeSystem.ICompilation,ICSharpCode.NRefactory.CSharp.Resolver.FoundReferenceCallback,System.Threading.CancellationToken)">
            <summary>
            Finds all references of a given variable.
            </summary>
            <param name="variable">The variable for which to look.</param>
            <param name="unresolvedFile">The type system representation of the file being searched.</param>
            <param name="syntaxTree">The syntax tree of the file being searched.</param>
            <param name="compilation">The compilation.</param>
            <param name="callback">Callback used to report the references that were found.</param>
            <param name="cancellationToken">Cancellation token that may be used to cancel the operation.</param>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.Resolver.FindReferences.FindTypeParameterReferences(ICSharpCode.NRefactory.TypeSystem.IType,ICSharpCode.NRefactory.CSharp.TypeSystem.CSharpUnresolvedFile,ICSharpCode.NRefactory.CSharp.SyntaxTree,ICSharpCode.NRefactory.TypeSystem.ICompilation,ICSharpCode.NRefactory.CSharp.Resolver.FoundReferenceCallback,System.Threading.CancellationToken)">
            <summary>
            Finds all references of a given type parameter.
            </summary>
            <param name="typeParameter">The type parameter for which to look.</param>
            <param name="unresolvedFile">The type system representation of the file being searched.</param>
            <param name="syntaxTree">The syntax tree of the file being searched.</param>
            <param name="compilation">The compilation.</param>
            <param name="callback">Callback used to report the references that were found.</param>
            <param name="cancellationToken">Cancellation token that may be used to cancel the operation.</param>
        </member>
        <member name="P:ICSharpCode.NRefactory.CSharp.Resolver.FindReferences.FindTypeReferencesEvenIfAliased">
            <summary>
            Specifies whether to find type references even if an alias is being used.
            Aliases may be <c>var</c> or <c>using Alias = ...;</c>.
            </summary>
        </member>
        <member name="P:ICSharpCode.NRefactory.CSharp.Resolver.FindReferences.FindOnlySpecializedReferences">
            <summary>
            Specifies whether find references should only look for specialized matches
            with equal type parameter substitution to the member we are searching for.
            </summary>
        </member>
        <member name="P:ICSharpCode.NRefactory.CSharp.Resolver.FindReferences.FindCallsThroughVirtualBaseMethod">
            <summary>
            If this option is enabled, find references on a overridden member
            will find calls to the base member.
            </summary>
        </member>
        <member name="P:ICSharpCode.NRefactory.CSharp.Resolver.FindReferences.FindCallsThroughInterface">
            <summary>
            If this option is enabled, find references on a member implementing
            an interface will also find calls to the interface.
            </summary>
        </member>
        <member name="P:ICSharpCode.NRefactory.CSharp.Resolver.FindReferences.WholeVirtualSlot">
            <summary>
            If this option is enabled, find references will look for all references
            to the virtual method slot.
            </summary>
        </member>
        <member name="P:ICSharpCode.NRefactory.CSharp.Resolver.FindReferences.SearchInDocumentationComments">
            <summary>
            Specifies whether to look for references in documentation comments.
            This will find entity references in <c>cref</c> attributes and
            parameter references in <c>&lt;param&gt;</c> and <c>&lt;paramref&gt;</c> tags.
            TODO: implement this feature.
            </summary>
        </member>
        <member name="T:ICSharpCode.NRefactory.CSharp.Resolver.IFindReferenceSearchScope">
            <summary>
            Represents a scope in which references are searched.
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.Resolver.IFindReferenceSearchScope.GetNavigator(ICSharpCode.NRefactory.TypeSystem.ICompilation,ICSharpCode.NRefactory.CSharp.Resolver.FoundReferenceCallback)">
            <summary>
            Creates a navigator that can find references to this entity and reports
            them to the specified callback.
            </summary>
        </member>
        <member name="P:ICSharpCode.NRefactory.CSharp.Resolver.IFindReferenceSearchScope.Compilation">
            <summary>
            Gets the compilation in which the entity being search for was defined.
            This is not necessarily the same compilation as is being searched in.
            </summary>
        </member>
        <member name="P:ICSharpCode.NRefactory.CSharp.Resolver.IFindReferenceSearchScope.SearchTerm">
            <summary>
            Gets the search term. Only files that contain this identifier need to be parsed.
            Can return null if all files need to be parsed.
            </summary>
        </member>
        <member name="P:ICSharpCode.NRefactory.CSharp.Resolver.IFindReferenceSearchScope.Accessibility">
            <summary>
            Gets the accessibility that defines the search scope.
            </summary>
        </member>
        <member name="P:ICSharpCode.NRefactory.CSharp.Resolver.IFindReferenceSearchScope.TopLevelTypeDefinition">
            <summary>
            Gets the top-level entity that defines the search scope.
            </summary>
        </member>
        <member name="T:ICSharpCode.NRefactory.CSharp.Resolver.ResolveVisitorNavigationMode">
            <summary>
            Represents the operation mode of the resolve visitor.
            </summary>
            <seealso cref="T:ICSharpCode.NRefactory.CSharp.Resolver.ResolveVisitor"/>
        </member>
        <member name="F:ICSharpCode.NRefactory.CSharp.Resolver.ResolveVisitorNavigationMode.Scan">
            <summary>
            Scan into the children of the current node, without resolving the current node.
            </summary>
        </member>
        <member name="F:ICSharpCode.NRefactory.CSharp.Resolver.ResolveVisitorNavigationMode.Skip">
            <summary>
            Skip the current node - do not scan into it; do not resolve it.
            </summary>
        </member>
        <member name="F:ICSharpCode.NRefactory.CSharp.Resolver.ResolveVisitorNavigationMode.Resolve">
            <summary>
            Resolve the current node.
            Subnodes which are not required for resolving the current node
            will ask the navigator again whether they should be resolved.
            </summary>
        </member>
        <member name="T:ICSharpCode.NRefactory.CSharp.Resolver.LambdaResolveResult">
            <summary>
            Represents an anonymous method or lambda expression.
            Note: the lambda has no type.
            To retrieve the delegate type, look at the anonymous function conversion.
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.Resolver.LambdaResolveResult.GetInferredReturnType(ICSharpCode.NRefactory.TypeSystem.IType[])">
            <summary>
            Gets the return type inferred when the parameter types are inferred to be <paramref name="parameterTypes"/>
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.Resolver.LambdaResolveResult.IsValid(ICSharpCode.NRefactory.TypeSystem.IType[],ICSharpCode.NRefactory.TypeSystem.IType,ICSharpCode.NRefactory.CSharp.Resolver.CSharpConversions)">
            <summary>
            Gets whether the lambda body is valid for the given parameter types and return type.
            </summary>
            <returns>
            Produces a conversion with <see cref="P:ICSharpCode.NRefactory.Semantics.Conversion.IsAnonymousFunctionConversion"/>=<c>true</c> if the lambda is valid;
            otherwise returns <see cref="F:ICSharpCode.NRefactory.Semantics.Conversion.None"/>.
            </returns>
        </member>
        <member name="P:ICSharpCode.NRefactory.CSharp.Resolver.LambdaResolveResult.HasParameterList">
            <summary>
            Gets whether there is a parameter list.
            This property always returns true for C# 3.0-lambdas, but may return false
            for C# 2.0 anonymous methods.
            </summary>
        </member>
        <member name="P:ICSharpCode.NRefactory.CSharp.Resolver.LambdaResolveResult.IsAnonymousMethod">
            <summary>
            Gets whether this lambda is using the C# 2.0 anonymous method syntax.
            </summary>
        </member>
        <member name="P:ICSharpCode.NRefactory.CSharp.Resolver.LambdaResolveResult.IsImplicitlyTyped">
            <summary>
            Gets whether the lambda parameters are implicitly typed.
            </summary>
            <remarks>This property returns false for anonymous methods without parameter list.</remarks>
        </member>
        <member name="P:ICSharpCode.NRefactory.CSharp.Resolver.LambdaResolveResult.IsAsync">
            <summary>
            Gets whether the lambda is async.
            </summary>
        </member>
        <member name="P:ICSharpCode.NRefactory.CSharp.Resolver.LambdaResolveResult.Parameters">
            <summary>
            Gets the list of parameters.
            </summary>
        </member>
        <member name="P:ICSharpCode.NRefactory.CSharp.Resolver.LambdaResolveResult.Body">
            <summary>
            Gets the resolve result for the lambda body.
            Returns a resolve result for 'void' for statement lambdas.
            </summary>
        </member>
        <member name="T:ICSharpCode.NRefactory.CSharp.Resolver.Log">
            <summary>
            Resolver logging helper.
            Wraps System.Diagnostics.Debug so that resolver-specific logging can be enabled/disabled on demand.
            (it's a huge amount of debug spew and slows down the resolver quite a bit)
            </summary>
        </member>
        <member name="T:ICSharpCode.NRefactory.CSharp.Resolver.MemberLookup">
            <summary>
            Implementation of member lookup (C# 4.0 spec, §7.4).
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.Resolver.MemberLookup.IsInvocable(ICSharpCode.NRefactory.TypeSystem.IMember)">
            <summary>
            Gets whether the member is considered to be invocable.
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.Resolver.MemberLookup.IsProtectedAccessAllowed(ICSharpCode.NRefactory.TypeSystem.IType)">
            <summary>
            Gets whether access to protected instance members of the target type is possible.
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.Resolver.MemberLookup.IsAccessible(ICSharpCode.NRefactory.TypeSystem.IEntity,System.Boolean)">
            <summary>
            Gets whether <paramref name="entity"/> is accessible in the current class.
            </summary>
            <param name="entity">The entity to test</param>
            <param name="allowProtectedAccess">
            Whether protected access to instance members is allowed.
            True if the type of the reference is derived from the current class.
            Protected static members may be accessibe even if false is passed for this parameter.
            </param>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.Resolver.MemberLookup.GetAccessibleMembers(ICSharpCode.NRefactory.Semantics.ResolveResult)">
            <summary>
            Retrieves all members that are accessible and not hidden (by being overridden or shadowed).
            Returns both members and nested type definitions. Does not include extension methods.
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.Resolver.MemberLookup.Lookup(ICSharpCode.NRefactory.Semantics.ResolveResult,System.String,System.Collections.Generic.IList{ICSharpCode.NRefactory.TypeSystem.IType},System.Boolean)">
            <summary>
            Performs a member lookup.
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.Resolver.MemberLookup.LookupIndexers(ICSharpCode.NRefactory.TypeSystem.IType)">
            <summary>
            Looks up the indexers on the target type.
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.Resolver.MemberLookup.AddNestedTypes(ICSharpCode.NRefactory.TypeSystem.IType,System.Collections.Generic.IEnumerable{ICSharpCode.NRefactory.TypeSystem.IType},System.Int32,System.Collections.Generic.List{ICSharpCode.NRefactory.CSharp.Resolver.MemberLookup.LookupGroup},System.Collections.Generic.IEnumerable{ICSharpCode.NRefactory.TypeSystem.IType}@,System.Collections.Generic.List{ICSharpCode.NRefactory.TypeSystem.IType}@)">
            <summary>
            Adds the nested types to 'newNestedTypes' and removes any hidden members from the existing lookup groups.
            </summary>
            <param name="type">Declaring type of the nested types</param>
            <param name="nestedTypes">List of nested types to add.</param>
            <param name="typeArgumentCount">The number of type arguments - used for hiding types from the base class</param>
            <param name="lookupGroups">List of existing lookup groups</param>
            <param name="typeBaseTypes">The base types of 'type' (initialized on demand)</param>
            <param name="newNestedTypes">The target list (created on demand).</param>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.Resolver.MemberLookup.AddMembers(ICSharpCode.NRefactory.TypeSystem.IType,System.Collections.Generic.IEnumerable{ICSharpCode.NRefactory.TypeSystem.IMember},System.Boolean,System.Collections.Generic.List{ICSharpCode.NRefactory.CSharp.Resolver.MemberLookup.LookupGroup},System.Boolean,System.Collections.Generic.IEnumerable{ICSharpCode.NRefactory.TypeSystem.IType}@,System.Collections.Generic.List{ICSharpCode.NRefactory.TypeSystem.IParameterizedMember}@,ICSharpCode.NRefactory.TypeSystem.IMember@)">
            <summary>
            Adds members to 'newMethods'/'newNonMethod'.
            Removes any members in the existing lookup groups that were hidden by added members.
            Substitutes 'virtual' members in the existing lookup groups for added 'override' members.
            </summary>
            <param name="type">Declaring type of the members</param>
            <param name="members">List of members to add.</param>
            <param name="allowProtectedAccess">Whether protected members are accessible</param>
            <param name="lookupGroups">List of existing lookup groups</param>
            <param name="treatAllParameterizedMembersAsMethods">Whether to treat properties as methods</param>
            <param name="typeBaseTypes">The base types of 'type' (initialized on demand)</param>
            <param name="newMethods">The target list for methods (created on demand).</param>
            <param name="newNonMethod">The target variable for non-method members.</param>
        </member>
        <member name="T:ICSharpCode.NRefactory.CSharp.Resolver.MethodListWithDeclaringType">
            <summary>
            A method list that belongs to a declaring type.
            </summary>
        </member>
        <member name="P:ICSharpCode.NRefactory.CSharp.Resolver.MethodListWithDeclaringType.DeclaringType">
            <summary>
            The declaring type.
            </summary>
            <remarks>
            Not all methods in this list necessarily have this as their declaring type.
            For example, this program:
            <code>
             class Base {
               public virtual void M() {}
             }
             class Derived : Base {
               public override void M() {}
               public void M(int i) {}
             }
            </code>
            results in two lists:
             <c>new MethodListWithDeclaringType(Base) { Derived.M() }</c>,
             <c>new MethodListWithDeclaringType(Derived) { Derived.M(int) }</c>
            </remarks>
        </member>
        <member name="T:ICSharpCode.NRefactory.CSharp.Resolver.MethodGroupResolveResult">
            <summary>
            Represents a group of methods.
            A method reference used to create a delegate is resolved to a MethodGroupResolveResult.
            The MethodGroupResolveResult has no type.
            To retrieve the delegate type or the chosen overload, look at the method group conversion.
            </summary>
        </member>
        <member name="F:ICSharpCode.NRefactory.CSharp.Resolver.MethodGroupResolveResult.extensionMethods">
            <summary>
            List of extension methods, used to avoid re-calculating it in ResolveInvocation() when it was already
            calculated by ResolveMemberAccess().
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.Resolver.MethodGroupResolveResult.GetExtensionMethods">
            <summary>
            Gets all candidate extension methods.
            Note: this includes candidates that are not eligible due to an inapplicable
            this argument.
            The candidates will only be specialized if the type arguments were provided explicitly.
            </summary>
            <remarks>
            The results are stored in nested lists because they are grouped by using scope.
            That is, for "using SomeExtensions; namespace X { using MoreExtensions; ... }",
            the return value will be
            new List {
               new List { all extensions from MoreExtensions },
               new List { all extensions from SomeExtensions }
            }
            </remarks>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.Resolver.MethodGroupResolveResult.GetEligibleExtensionMethods(System.Boolean)">
            <summary>
            Gets the eligible extension methods.
            </summary>
            <param name="substituteInferredTypes">
            Specifies whether to produce a <see cref="T:ICSharpCode.NRefactory.TypeSystem.Implementation.SpecializedMethod"/>
            when type arguments could be inferred from <see cref="P:ICSharpCode.NRefactory.CSharp.Resolver.MethodGroupResolveResult.TargetType"/>.
            This setting is only used for inferred types and has no effect if the type parameters are
            specified explicitly.
            </param>
            <remarks>
            The results are stored in nested lists because they are grouped by using scope.
            That is, for "using SomeExtensions; namespace X { using MoreExtensions; ... }",
            the return value will be
            new List {
               new List { all extensions from MoreExtensions },
               new List { all extensions from SomeExtensions }
            }
            </remarks>
        </member>
        <member name="P:ICSharpCode.NRefactory.CSharp.Resolver.MethodGroupResolveResult.TargetResult">
            <summary>
            Gets the resolve result for the target object.
            </summary>
        </member>
        <member name="P:ICSharpCode.NRefactory.CSharp.Resolver.MethodGroupResolveResult.TargetType">
            <summary>
            Gets the type of the reference to the target object.
            </summary>
        </member>
        <member name="P:ICSharpCode.NRefactory.CSharp.Resolver.MethodGroupResolveResult.MethodName">
            <summary>
            Gets the name of the methods in this group.
            </summary>
        </member>
        <member name="P:ICSharpCode.NRefactory.CSharp.Resolver.MethodGroupResolveResult.Methods">
            <summary>
            Gets the methods that were found.
            This list does not include extension methods.
            </summary>
        </member>
        <member name="P:ICSharpCode.NRefactory.CSharp.Resolver.MethodGroupResolveResult.MethodsGroupedByDeclaringType">
            <summary>
            Gets the methods that were found, grouped by their declaring type.
            This list does not include extension methods.
            Base types come first in the list.
            </summary>
        </member>
        <member name="P:ICSharpCode.NRefactory.CSharp.Resolver.MethodGroupResolveResult.TypeArguments">
            <summary>
            Gets the type arguments that were explicitly provided.
            </summary>
        </member>
        <member name="T:ICSharpCode.NRefactory.CSharp.Resolver.NodeListResolveVisitorNavigator">
            <summary>
            <see cref="T:ICSharpCode.NRefactory.CSharp.Resolver.IResolveVisitorNavigator"/> implementation that resolves a list of nodes.
            We will skip all nodes which are not the target nodes or ancestors of the target nodes.
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.Resolver.NodeListResolveVisitorNavigator.#ctor(ICSharpCode.NRefactory.CSharp.AstNode[])">
            <summary>
            Creates a new NodeListResolveVisitorNavigator that resolves the specified nodes.
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.Resolver.NodeListResolveVisitorNavigator.#ctor(System.Collections.Generic.IEnumerable{ICSharpCode.NRefactory.CSharp.AstNode},System.Boolean)">
            <summary>
            Creates a new NodeListResolveVisitorNavigator that resolves the specified nodes.
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.Resolver.NodeListResolveVisitorNavigator.Scan(ICSharpCode.NRefactory.CSharp.AstNode)">
            <inheritdoc/>
        </member>
        <member name="F:ICSharpCode.NRefactory.CSharp.Resolver.OverloadResolutionErrors.TooManyPositionalArguments">
            <summary>
            Too many positional arguments (some could not be mapped to any parameter).
            </summary>
        </member>
        <member name="F:ICSharpCode.NRefactory.CSharp.Resolver.OverloadResolutionErrors.NoParameterFoundForNamedArgument">
            <summary>
            A named argument could not be mapped to any parameter
            </summary>
        </member>
        <member name="F:ICSharpCode.NRefactory.CSharp.Resolver.OverloadResolutionErrors.TypeInferenceFailed">
            <summary>
            Type inference failed for a generic method.
            </summary>
        </member>
        <member name="F:ICSharpCode.NRefactory.CSharp.Resolver.OverloadResolutionErrors.WrongNumberOfTypeArguments">
            <summary>
            Type arguments were explicitly specified, but did not match the number of type parameters.
            </summary>
        </member>
        <member name="F:ICSharpCode.NRefactory.CSharp.Resolver.OverloadResolutionErrors.ConstructedTypeDoesNotSatisfyConstraint">
            <summary>
            After substituting type parameters with the inferred types; a constructed type within the formal parameters
            does not satisfy its constraint.
            </summary>
        </member>
        <member name="F:ICSharpCode.NRefactory.CSharp.Resolver.OverloadResolutionErrors.MissingArgumentForRequiredParameter">
            <summary>
            No argument was mapped to a non-optional parameter
            </summary>
        </member>
        <member name="F:ICSharpCode.NRefactory.CSharp.Resolver.OverloadResolutionErrors.MultipleArgumentsForSingleParameter">
            <summary>
            Several arguments were mapped to a single (non-params-array) parameter
            </summary>
        </member>
        <member name="F:ICSharpCode.NRefactory.CSharp.Resolver.OverloadResolutionErrors.ParameterPassingModeMismatch">
            <summary>
            'ref'/'out' passing mode doesn't match for at least 1 parameter
            </summary>
        </member>
        <member name="F:ICSharpCode.NRefactory.CSharp.Resolver.OverloadResolutionErrors.ArgumentTypeMismatch">
            <summary>
            Argument type cannot be converted to parameter type
            </summary>
        </member>
        <member name="F:ICSharpCode.NRefactory.CSharp.Resolver.OverloadResolutionErrors.AmbiguousMatch">
            <summary>
            There is no unique best overload.
            This error does not apply to any single candidate, but only to the overall result of overload resolution.
            </summary>
            <remarks>
            This error does not prevent a candidate from being applicable.
            </remarks>
        </member>
        <member name="F:ICSharpCode.NRefactory.CSharp.Resolver.OverloadResolutionErrors.Inaccessible">
            <summary>
            The member is not accessible.
            </summary>
            <remarks>
            This error is generated by member lookup; not by overload resolution.
            </remarks>
        </member>
        <member name="F:ICSharpCode.NRefactory.CSharp.Resolver.OverloadResolutionErrors.MethodConstraintsNotSatisfied">
            <summary>
            A generic method 
            </summary>
            <remarks>
            This error does not prevent a candidate from being applicable.
            </remarks>
        </member>
        <member name="T:ICSharpCode.NRefactory.CSharp.Resolver.ResolveAtLocation">
            <summary>
            Helper class that resolves the node at a specified location.
            Can be used for implementing tool tips.
            </summary>
        </member>
        <member name="T:ICSharpCode.NRefactory.CSharp.Resolver.ResolveVisitor">
            <summary>
            Traverses the DOM and resolves expressions.
            </summary>
            <remarks>
            The ResolveVisitor does two jobs at the same time: it tracks the resolve context (properties on CSharpResolver)
            and it resolves the expressions visited.
            To allow using the context tracking without having to resolve every expression in the file (e.g. when you want to resolve
            only a single node deep within the DOM), you can use the <see cref="T:ICSharpCode.NRefactory.CSharp.Resolver.IResolveVisitorNavigator"/> interface.
            The navigator allows you to switch the between scanning mode and resolving mode.
            In scanning mode, the context is tracked (local variables registered etc.), but nodes are not resolved.
            While scanning, the navigator will get asked about every node that the resolve visitor is about to enter.
            This allows the navigator whether to keep scanning, whether switch to resolving mode, or whether to completely skip the
            subtree rooted at that node.
            
            In resolving mode, the context is tracked and nodes will be resolved.
            The resolve visitor may decide that it needs to resolve other nodes as well in order to resolve the current node.
            In this case, those nodes will be resolved automatically, without asking the navigator interface.
            For child nodes that are not essential to resolving, the resolve visitor will switch back to scanning mode (and thus will
            ask the navigator for further instructions).
            
            Moreover, there is the <c>ResolveAll</c> mode - it works similar to resolving mode, but will not switch back to scanning mode.
            The whole subtree will be resolved without notifying the navigator.
            </remarks>
        </member>
        <member name="F:ICSharpCode.NRefactory.CSharp.Resolver.ResolveVisitor.currentQueryResult">
            <summary>Resolve result of the current LINQ query.</summary>
            <remarks>We do not have to put this into the stored state (resolver) because
            query expressions are always resolved in a single operation.</remarks>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.Resolver.ResolveVisitor.#ctor(ICSharpCode.NRefactory.CSharp.Resolver.CSharpResolver,ICSharpCode.NRefactory.CSharp.TypeSystem.CSharpUnresolvedFile)">
            <summary>
            Creates a new ResolveVisitor instance.
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.Resolver.ResolveVisitor.ResetContext(ICSharpCode.NRefactory.CSharp.Resolver.CSharpResolver,System.Action)">
            <summary>
            Resets the visitor to the stored position, runs the action, and then reverts the visitor to the previous position.
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.Resolver.ResolveVisitor.Scan(ICSharpCode.NRefactory.CSharp.AstNode)">
            <summary>
            Scans the AST rooted at the given node.
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.Resolver.ResolveVisitor.Resolve(ICSharpCode.NRefactory.CSharp.AstNode)">
            <summary>
            Equivalent to 'Scan', but also resolves the node at the same time.
            This method should be only used if the CSharpResolver passed to the ResolveVisitor was manually set
            to the correct state.
            Otherwise, use <c>resolver.Scan(syntaxTree); var result = resolver.GetResolveResult(node);</c>
            instead.
            --
            This method now is internal, because it is difficult to use correctly.
            Users of the public API should use Scan()+GetResolveResult() instead.
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.Resolver.ResolveVisitor.ProcessConversion(ICSharpCode.NRefactory.CSharp.Expression,ICSharpCode.NRefactory.Semantics.ResolveResult,ICSharpCode.NRefactory.Semantics.Conversion,ICSharpCode.NRefactory.TypeSystem.IType)">
            <summary>
            Convert 'rr' to the target type using the specified conversion.
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.Resolver.ResolveVisitor.ProcessConversion(ICSharpCode.NRefactory.CSharp.Expression,ICSharpCode.NRefactory.Semantics.ResolveResult,ICSharpCode.NRefactory.TypeSystem.IType)">
            <summary>
            Convert 'rr' to the target type.
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.Resolver.ResolveVisitor.ResolveAndProcessConversion(ICSharpCode.NRefactory.CSharp.Expression,ICSharpCode.NRefactory.TypeSystem.IType)">
            <summary>
            Resolves the specified expression and processes the conversion to targetType.
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.Resolver.ResolveVisitor.GetResolveResult(ICSharpCode.NRefactory.CSharp.AstNode)">
            <summary>
            Gets the resolve result for the specified node.
            If the node was not resolved by the navigator, this method will resolve it.
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.Resolver.ResolveVisitor.GetResolverStateBefore(ICSharpCode.NRefactory.CSharp.AstNode)">
            <summary>
            Gets the resolver state in front of the specified node.
            If the node was not visited by a previous scanning process, the
            AST will be scanned again to determine the state.
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.Resolver.ResolveVisitor.GetArguments(System.Collections.Generic.IEnumerable{ICSharpCode.NRefactory.CSharp.Expression},System.String[]@)">
            <summary>
            Gets and resolves the arguments; unpacking any NamedArgumentExpressions.
            </summary>
            <remarks>
            Callers of GetArguments must also call either ProcessConversionsInInvocation or MarkUnknownNamedArguments
            to ensure the named arguments get resolved.
            Also, as named arguments get resolved by the parent node, the parent node must not scan
            into the argument list without being resolved - see NeedsResolvingDueToNamedArguments().
            </remarks>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.Resolver.ResolveVisitor.IsStaticResult(ICSharpCode.NRefactory.Semantics.ResolveResult,ICSharpCode.NRefactory.Semantics.ResolveResult)">
            <summary>
            Gets whether 'rr' is considered a static access on the target identifier.
            </summary>
            <param name="rr">Resolve Result of the MemberReferenceExpression</param>
            <param name="invocationRR">Resolve Result of the InvocationExpression</param>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.Resolver.ResolveVisitor.UnpackTask(ICSharpCode.NRefactory.TypeSystem.IType)">
            <summary>
            Gets the T in Task&lt;T&gt;.
            Returns void for non-generic Task.
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.Resolver.ResolveVisitor.IsTask(ICSharpCode.NRefactory.TypeSystem.IType)">
            <summary>
            Gets whether the specified type is Task or Task&lt;T&gt;.
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.Resolver.ResolveVisitor.WrapResult(ICSharpCode.NRefactory.Semantics.ResolveResult)">
            <summary>
            Wraps the result in an identity conversion.
            This is necessary so that '$from x in variable$ select x*2' does not resolve
            to the LocalResolveResult for the variable, which would confuse find references.
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.Resolver.ResolveVisitor.GetSingleRangeVariable(ICSharpCode.NRefactory.CSharp.QueryExpression)">
            <summary>
            Gets the name of the range variable in the specified query.
            If the query has multiple range variables, this method returns null.
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.Resolver.ResolveVisitor.ImplicitlyTypedLambda.GetAnyHypothesis">
            <summary>
            Get any hypothesis for this lambda.
            This method is used as fallback if the lambda isn't merged the normal way (AnonymousFunctionConversion)
            </summary>
        </member>
        <member name="T:ICSharpCode.NRefactory.CSharp.Resolver.ResolveVisitor.LambdaTypeHypothesis">
            <summary>
            Every possible set of parameter types gets its own 'hypothetical world'.
            It uses a nested ResolveVisitor that has its own resolve cache, so that resolve results cannot leave the hypothetical world.
            
            Only after overload resolution is applied and the actual parameter types are known, the winning hypothesis will be merged
            with the parent ResolveVisitor.
            This is done when the AnonymousFunctionConversion is applied on the parent visitor.
            </summary>
        </member>
        <member name="F:ICSharpCode.NRefactory.CSharp.Resolver.TypeInferenceAlgorithm.CSharp4">
            <summary>
            C# 4.0 type inference.
            </summary>
        </member>
        <member name="F:ICSharpCode.NRefactory.CSharp.Resolver.TypeInferenceAlgorithm.Improved">
            <summary>
            Improved algorithm (not part of any specification) using FindTypeInBounds for fixing.
            </summary>
        </member>
        <member name="F:ICSharpCode.NRefactory.CSharp.Resolver.TypeInferenceAlgorithm.ImprovedReturnAllResults">
            <summary>
            Improved algorithm (not part of any specification) using FindTypeInBounds for fixing;
            uses <see cref="T:ICSharpCode.NRefactory.TypeSystem.IntersectionType"/> to report all results (in case of ambiguities).
            </summary>
        </member>
        <member name="T:ICSharpCode.NRefactory.CSharp.Resolver.TypeInference">
            <summary>
            Implements C# 4.0 Type Inference (§7.5.2).
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.Resolver.TypeInference.InferTypeArguments(System.Collections.Generic.IList{ICSharpCode.NRefactory.TypeSystem.ITypeParameter},System.Collections.Generic.IList{ICSharpCode.NRefactory.Semantics.ResolveResult},System.Collections.Generic.IList{ICSharpCode.NRefactory.TypeSystem.IType},System.Boolean@,System.Collections.Generic.IList{ICSharpCode.NRefactory.TypeSystem.IType})">
            <summary>
            Performs type inference.
            </summary>
            <param name="typeParameters">The method type parameters that should be inferred.</param>
            <param name="arguments">The arguments passed to the method.</param>
            <param name="parameterTypes">The parameter types of the method.</param>
            <param name="success">Out: whether type inference was successful</param>
            <param name="classTypeArguments">
            Class type arguments. These are substituted for class type parameters in the formal parameter types
            when inferring a method group or lambda.
            </param>
            <returns>The inferred type arguments.</returns>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.Resolver.TypeInference.InferTypeArgumentsFromBounds(System.Collections.Generic.IList{ICSharpCode.NRefactory.TypeSystem.ITypeParameter},ICSharpCode.NRefactory.TypeSystem.IType,System.Collections.Generic.IList{ICSharpCode.NRefactory.TypeSystem.IType},System.Collections.Generic.IList{ICSharpCode.NRefactory.TypeSystem.IType},System.Boolean@)">
            <summary>
            Infers type arguments for the <paramref name="typeParameters"/> occurring in the <paramref name="targetType"/>
            so that the resulting type (after substition) satisfies the given bounds.
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.Resolver.TypeInference.MakeExactInference(ICSharpCode.NRefactory.TypeSystem.IType,ICSharpCode.NRefactory.TypeSystem.IType)">
            <summary>
            Make exact inference from U to V.
            C# 4.0 spec: §7.5.2.8 Exact inferences
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.Resolver.TypeInference.MakeLowerBoundInference(ICSharpCode.NRefactory.TypeSystem.IType,ICSharpCode.NRefactory.TypeSystem.IType)">
            <summary>
            Make lower bound inference from U to V.
            C# 4.0 spec: §7.5.2.9 Lower-bound inferences
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.Resolver.TypeInference.MakeUpperBoundInference(ICSharpCode.NRefactory.TypeSystem.IType,ICSharpCode.NRefactory.TypeSystem.IType)">
            <summary>
            Make upper bound inference from U to V.
            C# 4.0 spec: §7.5.2.10 Upper-bound inferences
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.Resolver.TypeInference.GetBestCommonType(System.Collections.Generic.IList{ICSharpCode.NRefactory.Semantics.ResolveResult},System.Boolean@)">
            <summary>
            Gets the best common type (C# 4.0 spec: §7.5.2.14) of a set of expressions.
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.Resolver.TypeInference.FindTypeInBounds(System.Collections.Generic.IList{ICSharpCode.NRefactory.TypeSystem.IType},System.Collections.Generic.IList{ICSharpCode.NRefactory.TypeSystem.IType})">
            <summary>
            Finds a type that satisfies the given lower and upper bounds.
            </summary>
        </member>
        <member name="P:ICSharpCode.NRefactory.CSharp.Resolver.TypeInference.Algorithm">
            <summary>
            Gets/Sets the type inference algorithm used.
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.Completion.ICompletionDataFactory.CreateMemberCompletionData(ICSharpCode.NRefactory.TypeSystem.IType,ICSharpCode.NRefactory.TypeSystem.IEntity)">
            <summary>
            Creates the member completion data. 
            Form: Type.Member
            Used for generating enum members Foo.A, Foo.B where the enum 'Foo' is valid.
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.Completion.ICompletionDataFactory.CreateLiteralCompletionData(System.String,System.String,System.String)">
            <summary>
            Creates a generic completion data.
            </summary>
            <param name='title'>
            The title of the completion data
            </param>
            <param name='description'>
            The description of the literal.
            </param>
            <param name='insertText'>
            The insert text. If null, title is taken.
            </param>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.Completion.ICompletionDataFactory.CreateImportCompletionData(ICSharpCode.NRefactory.TypeSystem.IType,System.Boolean)">
            <summary>
            Creates a completion data that adds the required using for the created type.
            </summary>
            <param name="type">The type to import</param>
            <param name="useFullName">If set to true the full name of the type needs to be used.</param>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.Completion.IParameterCompletionDataFactory.CreateConstructorProvider(System.Int32,ICSharpCode.NRefactory.TypeSystem.IType,ICSharpCode.NRefactory.CSharp.AstNode)">
            <summary>
            Creates a constructor provider skipping the parent of thisInitializer.
            </summary>
        </member>
        <member name="F:ICSharpCode.NRefactory.CSharp.NameLookupMode.Expression">
            <summary>
            Normal name lookup in expressions
            </summary>
        </member>
        <member name="F:ICSharpCode.NRefactory.CSharp.NameLookupMode.InvocationTarget">
            <summary>
            Name lookup in expression, where the expression is the target of an invocation.
            Such a lookup will only return methods and delegate-typed fields.
            </summary>
        </member>
        <member name="F:ICSharpCode.NRefactory.CSharp.NameLookupMode.Type">
            <summary>
            Normal name lookup in type references.
            </summary>
        </member>
        <member name="F:ICSharpCode.NRefactory.CSharp.NameLookupMode.TypeInUsingDeclaration">
            <summary>
            Name lookup in the type reference inside a using declaration.
            </summary>
        </member>
        <member name="F:ICSharpCode.NRefactory.CSharp.NameLookupMode.BaseTypeReference">
            <summary>
            Name lookup for base type references.
            </summary>
        </member>
        <member name="T:ICSharpCode.NRefactory.CSharp.TypeSystem.AliasNamespaceReference">
            <summary>
            Looks up an alias (identifier in front of :: operator).
            </summary>
            <remarks>
            The member lookup performed by the :: operator is handled
            by <see cref="T:ICSharpCode.NRefactory.CSharp.TypeSystem.MemberTypeOrNamespaceReference"/>.
            </remarks>
        </member>
        <member name="T:ICSharpCode.NRefactory.CSharp.TypeSystem.TypeOrNamespaceReference">
            <summary>
            Represents a reference which could point to a type or namespace.
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.TypeSystem.TypeOrNamespaceReference.Resolve(ICSharpCode.NRefactory.CSharp.Resolver.CSharpResolver)">
            <summary>
            Resolves the reference and returns the ResolveResult.
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.TypeSystem.TypeOrNamespaceReference.ResolveType(ICSharpCode.NRefactory.CSharp.Resolver.CSharpResolver)">
            <summary>
            Returns the type that is referenced; or an <c>UnknownType</c> if the type isn't found.
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.TypeSystem.TypeOrNamespaceReference.ResolveNamespace(ICSharpCode.NRefactory.CSharp.Resolver.CSharpResolver)">
            <summary>
            Returns the namespace that is referenced; or null if no such namespace is found.
            </summary>
        </member>
        <member name="T:ICSharpCode.NRefactory.CSharp.TypeSystem.AttributeTypeReference">
            <summary>
            Type reference used within an attribute.
            Looks up both 'withoutSuffix' and 'withSuffix' and returns the type that exists.
            </summary>
        </member>
        <member name="T:ICSharpCode.NRefactory.CSharp.TypeSystem.ConstantValues.ErrorConstantValue">
            <summary>
            Used for constants that could not be converted to IConstantValue.
            </summary>
        </member>
        <member name="T:ICSharpCode.NRefactory.CSharp.TypeSystem.ConstantValues.IncrementConstantValue">
            <summary>
            Increments an integer <see cref="T:ICSharpCode.NRefactory.TypeSystem.IConstantValue"/> by a fixed amount without changing the type.
            </summary>
        </member>
        <member name="T:ICSharpCode.NRefactory.CSharp.TypeSystem.ConstantValues.PrimitiveConstantExpression">
            <summary>
            C#'s equivalent to the SimpleConstantValue.
            </summary>
        </member>
        <member name="T:ICSharpCode.NRefactory.CSharp.TypeSystem.ConstantValues.ConstantArrayCreation">
            <summary>
            Represents an array creation (as used within an attribute argument)
            </summary>
        </member>
        <member name="T:ICSharpCode.NRefactory.CSharp.TypeSystem.CSharpDocumentationComment">
            <summary>
            DocumentationComment with C# cref lookup.
            </summary>
        </member>
        <member name="T:ICSharpCode.NRefactory.CSharp.TypeSystem.CSharpUnresolvedFile">
            <summary>
            Represents a file that was parsed and converted for the type system.
            </summary>
        </member>
        <member name="T:ICSharpCode.NRefactory.CSharp.TypeSystem.ResolvedUsingScope">
            <summary>
            Resolved version of using scope.
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.TypeSystem.ResolvedUsingScope.HasAlias(System.String)">
            <summary>
            Gets whether this using scope has an alias (either using or extern)
            with the specified name.
            </summary>
        </member>
        <member name="T:ICSharpCode.NRefactory.CSharp.TypeSystem.MemberTypeOrNamespaceReference">
            <summary>
            Reference to a qualified type or namespace name.
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.TypeSystem.MemberTypeOrNamespaceReference.AddSuffix(System.String)">
            <summary>
            Adds a suffix to the identifier.
            Does not modify the existing type reference, but returns a new one.
            </summary>
        </member>
        <member name="T:ICSharpCode.NRefactory.CSharp.TypeSystem.SimpleTypeOrNamespaceReference">
            <summary>
            Represents a simple C# name. (a single non-qualified identifier with an optional list of type arguments)
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.TypeSystem.SimpleTypeOrNamespaceReference.AddSuffix(System.String)">
            <summary>
            Adds a suffix to the identifier.
            Does not modify the existing type reference, but returns a new one.
            </summary>
        </member>
        <member name="T:ICSharpCode.NRefactory.CSharp.TypeSystem.TypeSystemConvertVisitor">
            <summary>
            Produces type and member definitions from the DOM.
            </summary>
        </member>
        <member name="F:ICSharpCode.NRefactory.CSharp.TypeSystem.TypeSystemConvertVisitor.version">
            <summary>
            Version of the C# type system loader.
            Should be incremented when fixing bugs so that project contents cached on disk
            (which might be incorrect due to the bug) are re-created.
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.TypeSystem.TypeSystemConvertVisitor.#ctor(System.String)">
            <summary>
            Creates a new TypeSystemConvertVisitor.
            </summary>
            <param name="fileName">The file name (used for DomRegions).</param>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.TypeSystem.TypeSystemConvertVisitor.#ctor(ICSharpCode.NRefactory.CSharp.TypeSystem.CSharpUnresolvedFile,ICSharpCode.NRefactory.CSharp.TypeSystem.UsingScope,ICSharpCode.NRefactory.CSharp.TypeSystem.CSharpUnresolvedTypeDefinition)">
            <summary>
            Creates a new TypeSystemConvertVisitor and initializes it with a given context.
            </summary>
            <param name="unresolvedFile">The parsed file to which members should be added.</param>
            <param name="currentUsingScope">The current using scope.</param>
            <param name="currentTypeDefinition">The current type definition.</param>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.TypeSystem.TypeSystemConvertVisitor.AddDefaultMethodsToDelegate(ICSharpCode.NRefactory.TypeSystem.Implementation.DefaultUnresolvedTypeDefinition,ICSharpCode.NRefactory.TypeSystem.ITypeReference,System.Collections.Generic.IEnumerable{ICSharpCode.NRefactory.TypeSystem.IUnresolvedParameter})">
            <summary>
            Adds the 'Invoke', 'BeginInvoke', 'EndInvoke' methods, and a constructor, to the <paramref name="delegateType"/>.
            </summary>
        </member>
        <member name="P:ICSharpCode.NRefactory.CSharp.TypeSystem.TypeSystemConvertVisitor.InterningProvider">
            <summary>
            Gets/Sets the interning provider to use.
            The default value is a new <see cref="T:ICSharpCode.NRefactory.TypeSystem.Implementation.SimpleInterningProvider"/> instance.
            </summary>
        </member>
        <member name="P:ICSharpCode.NRefactory.CSharp.TypeSystem.TypeSystemConvertVisitor.SkipXmlDocumentation">
            <summary>
            Gets/Sets whether to ignore XML documentation.
            The default value is false.
            </summary>
        </member>
        <member name="T:ICSharpCode.NRefactory.CSharp.TypeSystem.UsingScope">
            <summary>
            Represents a scope that contains "using" statements.
            This is either the file itself, or a namespace declaration.
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.TypeSystem.UsingScope.#ctor">
            <summary>
            Creates a new root using scope.
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.TypeSystem.UsingScope.#ctor(ICSharpCode.NRefactory.CSharp.TypeSystem.UsingScope,System.String)">
            <summary>
            Creates a new nested using scope.
            </summary>
            <param name="parent">The parent using scope.</param>
            <param name="shortName">The short namespace name.</param>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.TypeSystem.UsingScope.HasAlias(System.String)">
            <summary>
            Gets whether this using scope has an alias (either using or extern)
            with the specified name.
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.TypeSystem.UsingScope.Resolve(ICSharpCode.NRefactory.TypeSystem.ICompilation)">
            <summary>
            Resolves the namespace represented by this using scope.
            </summary>
        </member>
        <member name="P:ICSharpCode.NRefactory.CSharp.PreProcessorDirective.Take">
            <summary>
            For an '#if' directive, specifies whether the condition evaluated to true.
            </summary>
        </member>
        <member name="T:ICSharpCode.NRefactory.CSharp.Completion.CSharpCompletionEngineBase">
            <summary>
            Acts as a common base between code completion and parameter completion.
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.Completion.CSharpCompletionEngine.GetImportCompletionData(System.Int32)">
            <summary>
            Gets the types that needs to be imported via using or full type name.
            </summary>
        </member>
        <member name="T:ICSharpCode.NRefactory.CSharp.TokenRole">
            <summary>
            A specific role only used for C# tokens
            </summary>
        </member>
        <member name="P:ICSharpCode.NRefactory.CSharp.TokenRole.Token">
            <summary>
            Gets the token as string. Note that the token Name and Token value may differ.
            </summary>
        </member>
        <member name="P:ICSharpCode.NRefactory.CSharp.TokenRole.Length">
            <summary>
            Gets the char length of the token.
            </summary>
        </member>
        <member name="T:ICSharpCode.NRefactory.CSharp.Refactoring.CodeIssue">
            <summary>
            A code issue marks a region of text with an issue and can provide solution actions for this issue.
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.Refactoring.CodeIssue.#ctor(System.String,ICSharpCode.NRefactory.TextLocation,ICSharpCode.NRefactory.TextLocation,System.Collections.Generic.IEnumerable{ICSharpCode.NRefactory.CSharp.Refactoring.CodeAction})">
            <summary>
            Initializes a new instance of the <see cref="T:ICSharpCode.NRefactory.CSharp.Refactoring.CodeIssue"/> class.
            </summary>
            <param name="description">
            The desription of the issue.
            </param>
            <param name="start">
            The issue start location.
            </param>
            <param name="end">
            the issue end location.
            </param>
            <param name="actions">
            A list of potential solutions for the issue.
            </param>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.Refactoring.CodeIssue.#ctor(System.String,ICSharpCode.NRefactory.TextLocation,ICSharpCode.NRefactory.TextLocation,ICSharpCode.NRefactory.CSharp.Refactoring.CodeAction)">
            <summary>
            Initializes a new instance of the <see cref="T:ICSharpCode.NRefactory.CSharp.Refactoring.CodeIssue"/> class.
            </summary>
            <param name="description">
            The desription of the issue.
            </param>
            <param name="start">
            The issue start location.
            </param>
            <param name="end">
            the issue end location.
            </param>
            <param name="action">
            A potential solution for the issue.
            </param>
        </member>
        <member name="P:ICSharpCode.NRefactory.CSharp.Refactoring.CodeIssue.Description">
            <summary>
            Gets the description of the issue.
            </summary>
        </member>
        <member name="P:ICSharpCode.NRefactory.CSharp.Refactoring.CodeIssue.Start">
            <summary>
            Gets the issue start location.
            </summary>
        </member>
        <member name="P:ICSharpCode.NRefactory.CSharp.Refactoring.CodeIssue.End">
            <summary>
            Gets the issue end location.
            </summary>
        </member>
        <member name="P:ICSharpCode.NRefactory.CSharp.Refactoring.CodeIssue.Actions">
            <summary>
            Gets a list of potential solutions for the issue.
            </summary>
        </member>
        <member name="T:ICSharpCode.NRefactory.CSharp.Refactoring.CodeAction">
            <summary>
            A code action provides a code transformation with a description.
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.Refactoring.CodeAction.#ctor(System.String,System.Action{ICSharpCode.NRefactory.CSharp.Refactoring.Script})">
            <summary>
            Initializes a new instance of the <see cref="T:ICSharpCode.NRefactory.CSharp.Refactoring.CodeAction"/> class.
            </summary>
            <param name="description">
            The description.
            </param>
            <param name="action">
            The code transformation.
            </param>
        </member>
        <member name="P:ICSharpCode.NRefactory.CSharp.Refactoring.CodeAction.Description">
            <summary>
            Gets the description.
            </summary>
        </member>
        <member name="P:ICSharpCode.NRefactory.CSharp.Refactoring.CodeAction.Run">
            <summary>
            Gets the code transformation.
            </summary>
        </member>
        <!-- Badly formed XML comment ignored for member "P:ICSharpCode.NRefactory.CSharp.ContextActionAttribute.BoundToIssue" -->
        <member name="T:ICSharpCode.NRefactory.CSharp.Severity">
            <summary>
            The severity influences how the task bar reacts on found issues.
            </summary>
        </member>
        <member name="F:ICSharpCode.NRefactory.CSharp.Severity.None">
            <summary>
            None means that the task bar doesn't show the issue.
            </summary>
        </member>
        <member name="F:ICSharpCode.NRefactory.CSharp.Severity.Error">
            <summary>
            Errors are shown in red and that the task bar is in error state if 1 error is found.
            </summary>
        </member>
        <member name="F:ICSharpCode.NRefactory.CSharp.Severity.Warning">
            <summary>
            Warnings are shown in yellow and set the task bar to warning state (if no error is found).
            </summary>
        </member>
        <member name="F:ICSharpCode.NRefactory.CSharp.Severity.Suggestion">
            <summary>
            Suggestions are shown in green and doesn't influence the task bar state
            </summary>
        </member>
        <member name="F:ICSharpCode.NRefactory.CSharp.Severity.Hint">
            <summary>
            Hints are shown in blue and doesn't influence the task bar state
            </summary>
        </member>
        <member name="T:ICSharpCode.NRefactory.CSharp.IssueMarker">
            <summary>
            The issue marker is used to set how an issue should be marked inside the text editor.
            </summary>
        </member>
        <member name="F:ICSharpCode.NRefactory.CSharp.IssueMarker.None">
            <summary>
            The issue is not shown inside the text editor. (But in the task bar)
            </summary>
        </member>
        <member name="F:ICSharpCode.NRefactory.CSharp.IssueMarker.Underline">
            <summary>
            The region is marked as underline in the severity color.
            </summary>
        </member>
        <member name="F:ICSharpCode.NRefactory.CSharp.IssueMarker.GrayOut">
            <summary>
            The text is grayed out.
            </summary>
        </member>
        <!-- Badly formed XML comment ignored for member "T:ICSharpCode.NRefactory.CSharp.Refactoring.ConditionalToNullCoalescingIssue" -->
        <member name="T:ICSharpCode.NRefactory.CSharp.Refactoring.NotImplementedExceptionIssue">
            <summary>
            This inspector just shows that there is a not implemented exception. It doesn't offer a fix.
            Should only be shown in overview bar, no underlining.
            </summary>
        </member>
        <member name="T:ICSharpCode.NRefactory.CSharp.Refactoring.RedundantInternalIssue">
            <summary>
            Finds redundant internal modifiers.
            </summary>
        </member>
        <member name="T:ICSharpCode.NRefactory.CSharp.Refactoring.RedundantNamespaceUsageIssue">
            <summary>
            Finds redundant namespace usages.
            </summary>
        </member>
        <member name="T:ICSharpCode.NRefactory.CSharp.Refactoring.RedundantPrivateIssue">
            <summary>
            Finds redundant internal modifiers.
            </summary>
        </member>
        <member name="T:ICSharpCode.NRefactory.CSharp.Refactoring.RedundantThisIssue">
            <summary>
            Finds redundant namespace usages.
            </summary>
        </member>
        <member name="P:ICSharpCode.NRefactory.CSharp.Refactoring.RedundantThisIssue.IgnoreConstructors">
            <summary>
            Specifies whether to ignore redundant 'this' in constructors.
            "this.Name = name;"
            </summary>
        </member>
        <member name="T:ICSharpCode.NRefactory.CSharp.Refactoring.RedundantUsingIssue">
            <summary>
            Finds redundant using declarations.
            </summary>
        </member>
        <member name="P:ICSharpCode.NRefactory.CSharp.Refactoring.RedundantUsingIssue.NamespacesToKeep">
            <summary>
            The list of namespaces that should be kept even if they are not being used.
            Used in SharpDevelop to always keep the "System" namespace around.
            </summary>
        </member>
        <member name="T:ICSharpCode.NRefactory.CSharp.Refactoring.StringIsNullOrEmptyIssue">
            <summary>
            Checks for str == null &amp;&amp; str == " "
            Converts to: string.IsNullOrEmpty (str)
            </summary>
        </member>
        <member name="T:ICSharpCode.NRefactory.CSharp.Refactoring.UseVarKeywordIssue">
            <summary>
            Checks for places where the 'var' keyword can be used. Note that the action is actually done with a context
            action.
            </summary>
        </member>
        <!-- Badly formed XML comment ignored for member "T:ICSharpCode.NRefactory.CSharp.Refactoring.IntroduceFormatItemAction" -->
        <member name="P:ICSharpCode.NRefactory.CSharp.Refactoring.CreateEventInvocatorAction.UseExplictType">
            <summary>
            If <c>true</c> an explicit type will be used for the handler variable; otherwise, 'var' will be used as type.
            Default value is <c>false</c>
            </summary>
        </member>
        <member name="T:ICSharpCode.NRefactory.CSharp.Refactoring.ConvertHexToDecAction">
            <summary>
            Convert a hex numer to dec. For example: 0x10 -> 16
            </summary>
        </member>
        <member name="T:ICSharpCode.NRefactory.CSharp.Refactoring.ConvertForeachToForAction">
            <summary>
            Converts a foreach loop to for.
            </summary>
        </member>
        <member name="T:ICSharpCode.NRefactory.CSharp.Refactoring.ConvertDecToHexAction">
            <summary>
            Convert a dec numer to hex. For example: 16 -> 0x10
            </summary>
        </member>
        <member name="T:ICSharpCode.NRefactory.CSharp.Refactoring.CheckIfParameterIsNullAction">
            <summary>
            Creates a 'if (param == null) throw new System.ArgumentNullException ();' contruct for a parameter.
            </summary>
        </member>
        <member name="T:ICSharpCode.NRefactory.CSharp.Refactoring.AddAnotherAccessorAction">
            <summary>
            Add another accessor to a property declaration that has only one.
            </summary>
        </member>
        <member name="F:ICSharpCode.NRefactory.CSharp.Refactoring.NamingStyle.PascalCase">
            <summary>
            PascalCase
            </summary>
        </member>
        <member name="F:ICSharpCode.NRefactory.CSharp.Refactoring.NamingStyle.CamelCase">
            <summary>
            camelCase
            </summary>
        </member>
        <member name="F:ICSharpCode.NRefactory.CSharp.Refactoring.NamingStyle.AllUpper">
            <summary>
            ALLUPPER
            </summary>
        </member>
        <member name="F:ICSharpCode.NRefactory.CSharp.Refactoring.NamingStyle.AllLower">
            <summary>
            alllower
            </summary>
        </member>
        <member name="F:ICSharpCode.NRefactory.CSharp.Refactoring.NamingStyle.FirstUpper">
            <summary>
            Firstupper
            </summary>
        </member>
        <member name="P:ICSharpCode.NRefactory.CSharp.Refactoring.NamingRule.RequiredPrefixes">
            <summary>
            If set, identifiers are required to be prefixed with one of these values.
            </summary>
        </member>
        <member name="P:ICSharpCode.NRefactory.CSharp.Refactoring.NamingRule.AllowedPrefixes">
            <summary>
            If set, identifiers are allowed to be prefixed with one of these values.
            </summary>
        </member>
        <member name="P:ICSharpCode.NRefactory.CSharp.Refactoring.NamingRule.RequiredSuffixes">
            <summary>
            If set, identifiers are required to be suffixed with one of these values.
            </summary>
        </member>
        <member name="P:ICSharpCode.NRefactory.CSharp.Refactoring.NamingRule.ForbiddenPrefixes">
            <summary>
            If set, identifiers cannot be prefixed by any of these values.
            </summary>
        </member>
        <!-- Badly formed XML comment ignored for member "P:ICSharpCode.NRefactory.CSharp.Refactoring.NamingRule.ForbiddenSuffixes" -->
        <member name="P:ICSharpCode.NRefactory.CSharp.Refactoring.NamingRule.AffectedEntity">
            <summary>
            Gets or sets the affected entity.
            </summary>
        </member>
        <member name="P:ICSharpCode.NRefactory.CSharp.Refactoring.NamingRule.VisibilityMask">
            <summary>
            Gets or sets the modifiers mask
            </summary>
        </member>
        <!-- Badly formed XML comment ignored for member "P:ICSharpCode.NRefactory.CSharp.Refactoring.NamingRule.NamingStyle" -->
        <member name="T:ICSharpCode.NRefactory.CSharp.TextEditorOptions">
            <summary>
            The text editor options class holds basic information about the text editor settings that influences code generation and formatting beside
            the CSharpFormattingOptions.
            </summary>
        </member>
        <member name="P:ICSharpCode.NRefactory.CSharp.TextEditorOptions.TabsToSpaces">
            <summary>
            Gets or sets a value indicating if tabs need to be replaced by spaces. If that is true, all indenting will be done with spaces only,
            otherwise the indenting will start with tabs.
            </summary>
        </member>
        <member name="P:ICSharpCode.NRefactory.CSharp.TextEditorOptions.TabSize">
            <summary>
            Gets or sets the size of the tab chacter as spaces.
            </summary>
        </member>
        <member name="P:ICSharpCode.NRefactory.CSharp.TextEditorOptions.IndentSize">
            <summary>
            Gets or sets the size of a single indent as spaces.
            </summary>
        </member>
        <member name="P:ICSharpCode.NRefactory.CSharp.TextEditorOptions.ContinuationIndent">
            <summary>
            Gets or sets the continuation indent. A continuation indent is the indent that will be put after an embedded statement that is no block.
            </summary>
        </member>
        <member name="P:ICSharpCode.NRefactory.CSharp.TextEditorOptions.LabelIndent">
            <summary>
            Gets or sets the label indent. A label indent is the indent that will be put before an label.
            (Note: it may be negative -IndentSize would cause that labels are unindented)
            </summary>
        </member>
        <member name="P:ICSharpCode.NRefactory.CSharp.TextEditorOptions.EolMarker">
            <summary>
            Gets or sets the eol marker.
            </summary>
        </member>
        <member name="P:ICSharpCode.NRefactory.CSharp.TextEditorOptions.IndentBlankLines">
            <summary>
            If true blank lines will be indented up to the indent level, otherwise blank lines will have the length 0.
            </summary>
        </member>
        <member name="P:ICSharpCode.NRefactory.CSharp.TextEditorOptions.WrapLineLength">
            <summary>
            Gets or sets the length of the desired line length. The formatting engine will wrap at wrap points set to Wrapping.WrapIfTooLong if the line length is too long.
            0 means do not wrap.
            </summary>
        </member>
        <member name="T:ICSharpCode.NRefactory.CSharp.NewLineNode">
            <summary>
            A New line node represents a line break in the text.
            </summary>
        </member>
        <member name="T:ICSharpCode.NRefactory.CSharp.WhitespaceNode">
            <summary>
            A Whitespace node contains only whitespaces.
            </summary>
        </member>
        <member name="T:ICSharpCode.NRefactory.CSharp.TextNode">
            <summary>
            A text node contains text without syntactic or semantic information.
            (non parseable part of a text)
            </summary>
        </member>
        <member name="T:ICSharpCode.NRefactory.CSharp.FormattingOptionsFactory">
            <summary>
            The formatting options factory creates pre defined formatting option styles.
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.FormattingOptionsFactory.CreateEmpty">
            <summary>
            Creates empty CSharpFormatting options.
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.FormattingOptionsFactory.CreateMono">
            <summary>
            Creates mono indent style CSharpFormatting options.
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.FormattingOptionsFactory.CreateSharpDevelop">
            <summary>
            Creates sharp develop indent style CSharpFormatting options.
            </summary>
        </member>
        <!-- Badly formed XML comment ignored for member "M:ICSharpCode.NRefactory.CSharp.FormattingOptionsFactory.CreateKRStyle" -->
        <member name="M:ICSharpCode.NRefactory.CSharp.FormattingOptionsFactory.CreateAllman">
            <summary>
            Creates allman indent style CSharpFormatting options used in Visual Studio.
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.FormattingOptionsFactory.CreateWhitesmiths">
            <summary>
            The Whitesmiths style, also called Wishart style to a lesser extent, is less common today than the previous three. It was originally used in the documentation for the first commercial C compiler, the Whitesmiths Compiler.
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.FormattingOptionsFactory.CreateGNU">
            <summary>
            Like the Allman and Whitesmiths styles, GNU style puts braces on a line by themselves, indented by 2 spaces,
            except when opening a function definition, where they are not indented.
            In either case, the contained code is indented by 2 spaces from the braces.
            Popularised by Richard Stallman, the layout may be influenced by his background of writing Lisp code.
            In Lisp the equivalent to a block (a progn) 
            is a first class data entity and giving it its own indent level helps to emphasize that,
            whereas in C a block is just syntax.
            Although not directly related to indentation, GNU coding style also includes a space before the bracketed 
            list of arguments to a function.
            </summary>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.Refactoring.NamingHelper.GenerateVariableName(ICSharpCode.NRefactory.CSharp.AstType,System.String)">
            <summary>
            Generates a variable name for a variable of the specified type.
            </summary>
            <returns>
            The variable name.
            </returns>
            <param name='type'>
            The type of the variable.
            </param>
            <param name='baseName'>
            Suggested base name.
            </param>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.Refactoring.NamingHelper.GenerateVariableName(ICSharpCode.NRefactory.TypeSystem.IType,System.String)">
            <summary>
            Generates a variable name for a variable of the specified type.
            </summary>
            <returns>
            The variable name.
            </returns>
            <param name='type'>
            The type of the variable.
            </param>
            <param name='baseName'>
            Suggested base name.
            </param>
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.Refactoring.ITypeCriterion.SatisfiedBy(ICSharpCode.NRefactory.TypeSystem.IType)">
            <summary>
            Checks if the given type satisfies the critrion.
            </summary>
            <returns>
            <c>true</c>, if the type satisfies the criterion, <c>false</c> otherwise.
            </returns>
            <param name='type'>
            The type to check.
            </param>
        </member>
        <member name="P:Mono.CSharp.SeekableStreamReader.Position">
            <remarks>
              This value corresponds to the current position in a stream of characters.
              The StreamReader hides its manipulation of the underlying byte stream and all
              character set/decoding issues.  Thus, we cannot use this position to guess at
              the corresponding position in the underlying byte stream even though there is
              a correlation between them.
            </remarks>
        </member>
        <member name="T:ICSharpCode.NRefactory.CSharp.Refactoring.LocalReferenceFinder">
            <summary>
            Finds references to <see cref="T:ICSharpCode.NRefactory.TypeSystem.IVariable">IVariables</see>.
            </summary>
            <remarks>
            This class is more efficient than <see cref="M:ICSharpCode.NRefactory.CSharp.Refactoring.LocalReferenceFinder.FindReferences(ICSharpCode.NRefactory.CSharp.AstNode,ICSharpCode.NRefactory.TypeSystem.IVariable)"/>
            if there is already a resolved tree or if multiple searches needs
            to be performed.
            </remarks>		
        </member>
        <member name="M:ICSharpCode.NRefactory.CSharp.Refactoring.LocalReferenceFinder.FindReferences(ICSharpCode.NRefactory.CSharp.AstNode,ICSharpCode.NRefactory.TypeSystem.IVariable)">
            <summary>
            Finds the references to <paramref name="variable"/>.
            </summary>
            <param name="rootNode">
            Root node for the search.
            </param>
            <param name="variable">
            The variable to find references for.
            </param>
            <remarks>
            When a single <see cref="T:ICSharpCode.NRefactory.CSharp.Refactoring.LocalReferenceFinder"/> is reused for multiple
            searches, which references outside of <paramref name="rootNode"/> are
            or are not reported is undefined.
            </remarks>
        </member>
    </members>
</doc>
